diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/remove_volatile.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/remove_volatile.h
new file mode 100644
index 0000000000000000000000000000000000000000..58e70a50e30d2623c21769a68717fe69b4268117
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/remove_volatile.h
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_REMOVE_VOLATILE_H
+#define _LIBCUDACXX___TYPE_TRAITS_REMOVE_VOLATILE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_REMOVE_VOLATILE) && !defined(_LIBCUDACXX_USE_REMOVE_VOLATILE_FALLBACK)
+template <class _Tp>
+struct remove_volatile {
+  using type _LIBCUDACXX_NODEBUG_TYPE = _LIBCUDACXX_REMOVE_VOLATILE(_Tp);
+};
+
+template <class _Tp>
+using __remove_volatile_t = _LIBCUDACXX_REMOVE_VOLATILE(_Tp);
+
+#else
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS remove_volatile               {typedef _Tp type;};
+template <class _Tp> struct _LIBCUDACXX_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
+
+template <class _Tp>
+using __remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+#endif // defined(_LIBCUDACXX_REMOVE_VOLATILE) && !defined(_LIBCUDACXX_USE_REMOVE_VOLATILE_FALLBACK)
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_REMOVE_VOLATILE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/result_of.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/result_of.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c8d772c3255cc9f916043839fdcfade4cd35dbd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/result_of.h
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_RESULT_OF_H
+#define _LIBCUDACXX___TYPE_TRAITS_RESULT_OF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// result_of
+
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
+template <class _Callable> class _LIBCUDACXX_DEPRECATED_IN_CXX17 result_of;
+
+template <class _Fp, class ..._Args>
+class _LIBCUDACXX_TEMPLATE_VIS result_of<_Fp(_Args...)>
+    : public __invoke_of<_Fp, _Args...>
+{
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using result_of_t _LIBCUDACXX_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
+#endif // _LIBCUDACXX_STD_VER > 11
+#endif // _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_RESULT_OF_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_identity.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_identity.h
new file mode 100644
index 0000000000000000000000000000000000000000..f76ed081d1a7efde765ac3777ef8c059b55bcd2c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_identity.h
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_TYPE_IDENTITY_H
+#define _LIBCUDACXX___TYPE_TRAITS_TYPE_IDENTITY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __type_identity { typedef _Tp type; };
+
+template <class _Tp>
+using __type_identity_t _LIBCUDACXX_NODEBUG_TYPE = typename __type_identity<_Tp>::type;
+
+#if _LIBCUDACXX_STD_VER > 11
+template<class _Tp> struct type_identity { typedef _Tp type; };
+template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_TYPE_IDENTITY_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_list.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_list.h
new file mode 100644
index 0000000000000000000000000000000000000000..328e88b811ee107390a24b58a5eb8bbd62a805ab
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/type_list.h
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_TYPE_LIST_H
+#define _LIBCUDACXX___TYPE_TRAITS_TYPE_LIST_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Hp, class _Tp>
+struct __type_list
+{
+    typedef _Hp _Head;
+    typedef _Tp _Tail;
+};
+
+template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
+
+template <class _Hp, class _Tp, size_t _Size>
+struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE _Hp type;
+};
+
+template <class _Hp, class _Tp, size_t _Size>
+struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE typename __find_first<_Tp, _Size>::type type;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_TYPE_LIST_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/underlying_type.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/underlying_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..88f860ee0a2ec386f88a280262445166a9d41a91
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/underlying_type.h
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_UNDERLYING_TYPE_H
+#define _LIBCUDACXX___TYPE_TRAITS_UNDERLYING_TYPE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_enum.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_UNDERLYING_TYPE) && !defined(_LIBCUDACXX_USE_UNDERLYING_TYPE_FALLBACK)
+
+template <class _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl;
+
+template <class _Tp>
+struct __underlying_type_impl<_Tp, false> {};
+
+template <class _Tp>
+struct __underlying_type_impl<_Tp, true>
+{
+    typedef _LIBCUDACXX_UNDERLYING_TYPE(_Tp) type;
+};
+
+template <class _Tp>
+struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
+#endif
+
+#else
+
+template <class _Tp, bool _Support = false>
+struct underlying_type
+{
+    static_assert(_Support, "The underyling_type trait requires compiler "
+                            "support. Either no such support exists or "
+                            "libc++ does not know how to use it.");
+};
+
+#endif // defined(_LIBCUDACXX_UNDERLYING_TYPE) && !defined(_LIBCUDACXX_USE_UNDERLYING_TYPE_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_UNDERLYING_TYPE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/void_t.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/void_t.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cf29a19c9861f92cd52bdf023d554438eb309a5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__type_traits/void_t.h
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_VOID_T_H
+#define _LIBCUDACXX___TYPE_TRAITS_VOID_T_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class...> using void_t = void;
+#endif
+
+template <class...>
+using __void_t = void;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_VOID_T_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/as_const.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/as_const.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d8e92a48ca873449dfadc140609eae09b2029c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/as_const.h
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_AS_CONST_H
+#define _LIBCUDACXX___UTILITY_AS_CONST_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/add_const.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
+
+template <class _Tp>
+void as_const(const _Tp&&) = delete;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_AS_CONST_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/auto_cast.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/auto_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..dba7b3f22090778e00c235ad2947ea96a8e09d51
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/auto_cast.h
@@ -0,0 +1,26 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_AUTO_CAST_H
+#define _LIBCUDACXX___UTILITY_AUTO_CAST_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/decay.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#define _LIBCUDACXX_AUTO_CAST(expr) static_cast<_CUDA_VSTD::decay_t<decltype((expr))>>(expr)
+
+#endif // _LIBCUDACXX___UTILITY_AUTO_CAST_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/cmp.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/cmp.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab4c7476fedcc776563ab6599b299381f2c8b2a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/cmp.h
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_CMP_H
+#define _LIBCUDACXX___UTILITY_CMP_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+#include "../__type_traits/disjunction.h"
+#include "../__type_traits/is_integral.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_signed.h"
+#include "../__type_traits/make_unsigned.h"
+#include "../limits"
+
+#ifndef __cuda_std__
+#include <__pragma_push>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+template<class _Tp, class... _Up>
+struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
+
+template<class _Tp>
+concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
+                      !_IsSameAsAny<_Tp, bool, char, char16_t, char32_t
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+                                    , char8_t
+#endif
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+                                    , wchar_t
+#endif
+                                    >::value;
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_equal(_Tp __t, _Up __u) noexcept
+{
+  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+    return __t == __u;
+  else if constexpr (is_signed_v<_Tp>)
+    return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
+  else
+    return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_not_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_CUDA_VSTD::cmp_equal(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_less(_Tp __t, _Up __u) noexcept
+{
+  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+    return __t < __u;
+  else if constexpr (is_signed_v<_Tp>)
+    return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
+  else
+    return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_greater(_Tp __t, _Up __u) noexcept
+{
+  return _CUDA_VSTD::cmp_less(__u, __t);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_less_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_CUDA_VSTD::cmp_greater(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
+{
+  return !_CUDA_VSTD::cmp_less(__t, __u);
+}
+
+template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr
+bool in_range(_Up __u) noexcept
+{
+  return _CUDA_VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
+         _CUDA_VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
+}
+#endif // _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#ifndef __cuda_std__
+#include <__pragma_pop>
+#endif // __cuda_std__
+
+#endif // _LIBCUDACXX___UTILITY_CMP_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/convert_to_integral.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/convert_to_integral.h
new file mode 100644
index 0000000000000000000000000000000000000000..cef2994931bcf5179a1edc110b09c7a57e98f4a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/convert_to_integral.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_CONVERT_TO_INTEGRAL_H
+#define _LIBCUDACXX___UTILITY_CONVERT_TO_INTEGRAL_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_enum.h"
+#include "../__type_traits/is_floating_point.h"
+#include "../__type_traits/underlying_type.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+int __convert_to_integral(int __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+unsigned __convert_to_integral(unsigned __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+long __convert_to_integral(long __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+unsigned long __convert_to_integral(unsigned long __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+long long __convert_to_integral(long long __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }
+
+template<typename _Fp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+__enable_if_t<is_floating_point<_Fp>::value, long long>
+ __convert_to_integral(_Fp __val) { return __val; }
+
+#ifndef _LIBCUDACXX_HAS_NO_INT128
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+__int128_t __convert_to_integral(__int128_t __val) { return __val; }
+
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+__uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
+#endif
+
+template <class _Tp, bool = is_enum<_Tp>::value>
+struct __sfinae_underlying_type
+{
+    typedef typename underlying_type<_Tp>::type type;
+    typedef decltype(((type)1) + 0) __promoted_type;
+};
+
+template <class _Tp>
+struct __sfinae_underlying_type<_Tp, false> {};
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+typename __sfinae_underlying_type<_Tp>::__promoted_type
+__convert_to_integral(_Tp __val) { return __val; }
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_CONVERT_TO_INTEGRAL_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/declval.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/declval.h
new file mode 100644
index 0000000000000000000000000000000000000000..8025dac89370cf35f46e7a22617153d8bcc68448
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/declval.h
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_DECLVAL_H
+#define _LIBCUDACXX___UTILITY_DECLVAL_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Suppress deprecation notice for volatile-qualified return type resulting
+// from volatile-qualified types _Tp.
+_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _Tp&& __declval(int);
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _Tp __declval(long);
+_LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY decltype(_CUDA_VSTD::__declval<_Tp>(0)) declval() _NOEXCEPT;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_DECLVAL_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exception_guard.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exception_guard.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc15354eb15b926b9b23704136602dd9f82c806c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exception_guard.h
@@ -0,0 +1,149 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_EXCEPTION_GUARD_H
+#define _LIBCUDACXX___UTILITY_EXCEPTION_GUARD_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__utility/exchange.h"
+#include "../__utility/move.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// __exception_guard is a helper class for writing code with the strong exception guarantee.
+//
+// When writing code that can throw an exception, one can store rollback instructions in an
+// exception guard so that if an exception is thrown at any point during the lifetime of the
+// exception guard, it will be rolled back automatically. When the exception guard is done, one
+// must mark it as being complete so it isn't rolled back when the exception guard is destroyed.
+//
+// Exception guards are not default constructible, they can't be copied or assigned to, but
+// they can be moved around for convenience.
+//
+// __exception_guard is a no-op in -fno-exceptions mode to produce better code-gen. This means
+// that we don't provide the strong exception guarantees. However, Clang doesn't generate cleanup
+// code with exceptions disabled, so even if we wanted to provide the strong exception guarantees
+// we couldn't. This is also only relevant for constructs with a stack of
+// -fexceptions > -fno-exceptions > -fexceptions code, since the exception can't be caught where
+// exceptions are disabled. While -fexceptions > -fno-exceptions is quite common
+// (e.g. libc++.dylib > -fno-exceptions), having another layer with exceptions enabled seems a lot
+// less common, especially one that tries to catch an exception through -fno-exceptions code.
+//
+// __exception_guard can help greatly simplify code that would normally be cluttered by
+// `#if _LIBCUDACXX_NO_EXCEPTIONS`. For example:
+//
+//    template <class Iterator, class Size, class OutputIterator>
+//    Iterator uninitialized_copy_n(Iterator iter, Size n, OutputIterator out) {
+//        typedef typename iterator_traits<Iterator>::value_type value_type;
+//        __exception_guard guard([start=out, &out] {
+//            _CUDA_VSTD::destroy(start, out);
+//        });
+//
+//        for (; n > 0; ++iter, ++out, --n) {
+//            ::new ((void*)_CUDA_VSTD::addressof(*out)) value_type(*iter);
+//        }
+//        guard.__complete();
+//        return out;
+//    }
+//
+
+template <class _Rollback>
+struct __exception_guard_exceptions {
+  __exception_guard_exceptions() = delete;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  explicit __exception_guard_exceptions(_Rollback __rollback)
+      : __rollback_(_CUDA_VSTD::move(__rollback)), __completed_(false) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  __exception_guard_exceptions(__exception_guard_exceptions&& __other)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Rollback))
+      : __rollback_(_CUDA_VSTD::move(__other.__rollback_)), __completed_(__other.__completed_) {
+    __other.__completed_ = true;
+  }
+
+  __exception_guard_exceptions(__exception_guard_exceptions const&)            = delete;
+  __exception_guard_exceptions& operator=(__exception_guard_exceptions const&) = delete;
+  __exception_guard_exceptions& operator=(__exception_guard_exceptions&&)      = delete;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  void __complete() noexcept { __completed_ = true; }
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+  ~__exception_guard_exceptions() {
+    if (!__completed_)
+      __rollback_();
+  }
+
+private:
+  _Rollback __rollback_;
+  bool __completed_;
+};
+
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_exceptions);
+
+template <class _Rollback>
+struct __exception_guard_noexceptions {
+  __exception_guard_noexceptions() = delete;
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _LIBCUDACXX_NODEBUG
+  explicit __exception_guard_noexceptions(_Rollback) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _LIBCUDACXX_NODEBUG
+  __exception_guard_noexceptions(__exception_guard_noexceptions&& __other)
+      noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Rollback))
+      : __completed_(__other.__completed_) {
+    __other.__completed_ = true;
+  }
+
+  __exception_guard_noexceptions(__exception_guard_noexceptions const&)            = delete;
+  __exception_guard_noexceptions& operator=(__exception_guard_noexceptions const&) = delete;
+  __exception_guard_noexceptions& operator=(__exception_guard_noexceptions&&)      = delete;
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _LIBCUDACXX_NODEBUG
+  void __complete() _NOEXCEPT {
+    __completed_ = true;
+  }
+
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 _LIBCUDACXX_NODEBUG
+  ~__exception_guard_noexceptions() {
+    _LIBCUDACXX_ASSERT(__completed_, "__exception_guard not completed with exceptions disabled");
+  }
+
+private:
+  bool __completed_ = false;
+};
+
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_noexceptions);
+
+#ifdef _LIBCUDACXX_NO_EXCEPTIONS
+template <class _Rollback>
+using __exception_guard = __exception_guard_noexceptions<_Rollback>;
+#else
+template <class _Rollback>
+using __exception_guard = __exception_guard_exceptions<_Rollback>;
+#endif
+
+template <class _Rollback>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+__exception_guard<_Rollback> __make_exception_guard(_Rollback __rollback) {
+  return __exception_guard<_Rollback>(_CUDA_VSTD::move(__rollback));
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_EXCEPTION_GUARD_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exchange.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exchange.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0ac808e86c175eb2a3ca47802927e562b71dbe5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/exchange.h
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_EXCHANGE_H
+#define _LIBCUDACXX___UTILITY_EXCHANGE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_nothrow_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+template<class _T1, class _T2 = _T1>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+_T1 exchange(_T1& __obj, _T2&& __new_value)
+    noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value)
+{
+    _T1 __old_value = _CUDA_VSTD::move(__obj);
+    __obj = _CUDA_VSTD::forward<_T2>(__new_value);
+    return __old_value;
+}
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_EXCHANGE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward.h
new file mode 100644
index 0000000000000000000000000000000000000000..73f493d190597c46b1b62a992c23defd7078388e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward.h
@@ -0,0 +1,43 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_FORWARD_H
+#define _LIBCUDACXX___UTILITY_FORWARD_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/remove_reference.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR _Tp&&
+forward(__libcpp_remove_reference_t<_Tp>& __t) _NOEXCEPT {
+  return static_cast<_Tp&&>(__t);
+}
+
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR _Tp&&
+forward(__libcpp_remove_reference_t<_Tp>&& __t) _NOEXCEPT {
+  static_assert(!is_lvalue_reference<_Tp>::value, "cannot forward an rvalue as an lvalue");
+  return static_cast<_Tp&&>(__t);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_FORWARD_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward_like.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward_like.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4d740765fa3cd65932d5ff8e228a3daa36a8d0c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/forward_like.h
@@ -0,0 +1,50 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_FORWARD_LIKE_H
+#define _LIBCUDACXX___UTILITY_FORWARD_LIKE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/is_const.h"
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 20
+
+template <class _Ap, class _Bp>
+using _CopyConst = _If<is_const_v<_Ap>, const _Bp, _Bp>;
+
+template <class _Ap, class _Bp>
+using _OverrideRef = _If<is_rvalue_reference_v<_Ap>, remove_reference_t<_Bp>&&, _Bp&>;
+
+template <class _Ap, class _Bp>
+using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>;
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_NODISCARD_ATTRIBUTE _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto forward_like(_Up&& __ux) noexcept -> _ForwardLike<_Tp, _Up> {
+  return static_cast<_ForwardLike<_Tp, _Up>>(__ux);
+}
+
+#endif // _LIBCUDACXX_STD_VER > 20
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_FORWARD_LIKE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/in_place.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/in_place.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f5369fc39214c007e94c6333642423dcc7a0528
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/in_place.h
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_IN_PLACE_H
+#define _LIBCUDACXX___UTILITY_IN_PLACE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_reference.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+struct _LIBCUDACXX_TYPE_VIS in_place_t {
+    explicit in_place_t() = default;
+};
+_LIBCUDACXX_CPO_ACCESSIBILITY in_place_t in_place{};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS in_place_type_t {
+    explicit in_place_type_t() = default;
+};
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr in_place_type_t<_Tp> in_place_type{};
+
+template <size_t _Idx>
+struct _LIBCUDACXX_TEMPLATE_VIS in_place_index_t {
+    explicit in_place_index_t() = default;
+};
+template <size_t _Idx>
+_LIBCUDACXX_INLINE_VAR constexpr in_place_index_t<_Idx> in_place_index{};
+
+template <class _Tp> struct __is_inplace_type_imp : false_type {};
+template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
+
+template <class _Tp>
+using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>;
+
+template <class _Tp> struct __is_inplace_index_imp : false_type {};
+template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
+
+template <class _Tp>
+using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_IN_PLACE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/integer_sequence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/integer_sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0c7d7406e29a6bf004437395f37ff90184d360d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/integer_sequence.h
@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_INTEGER_SEQUENCE_H
+#define _LIBCUDACXX___UTILITY_INTEGER_SEQUENCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/is_integral.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <size_t...> struct __tuple_indices {};
+
+template <class _IdxType, _IdxType... _Values>
+struct __integer_sequence {
+  template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>
+  using __convert = _ToIndexSeq<_ToIndexType, _Values...>;
+
+  template <size_t _Sp>
+  using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
+};
+
+#if !__has_builtin(__make_integer_seq) || defined(_LIBCUDACXX_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+
+namespace __detail {
+
+template<typename _Tp, size_t ..._Extra> struct __repeat;
+template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
+  typedef _LIBCUDACXX_NODEBUG_TYPE __integer_sequence<_Tp,
+                           _Np...,
+                           sizeof...(_Np) + _Np...,
+                           2 * sizeof...(_Np) + _Np...,
+                           3 * sizeof...(_Np) + _Np...,
+                           4 * sizeof...(_Np) + _Np...,
+                           5 * sizeof...(_Np) + _Np...,
+                           6 * sizeof...(_Np) + _Np...,
+                           7 * sizeof...(_Np) + _Np...,
+                           _Extra...> type;
+};
+
+template<size_t _Np> struct __parity;
+template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
+
+template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
+template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
+template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
+template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
+template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
+template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
+template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
+template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
+
+template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
+template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
+template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+
+} // namespace detail
+
+#endif  // !__has_builtin(__make_integer_seq) || defined(_LIBCUDACXX_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+
+#if __has_builtin(__make_integer_seq)
+template <size_t _Ep, size_t _Sp>
+using __make_indices_imp =
+    typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
+    __to_tuple_indices<_Sp>;
+#else
+template <size_t _Ep, size_t _Sp>
+using __make_indices_imp =
+    typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
+
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, _Tp... _Ip>
+struct _LIBCUDACXX_TEMPLATE_VIS integer_sequence
+{
+    typedef _Tp value_type;
+    static_assert( is_integral<_Tp>::value,
+                  "std::integer_sequence can only be instantiated with an integral type" );
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr
+    size_t
+    size() noexcept { return sizeof...(_Ip); }
+};
+
+template<size_t... _Ip>
+    using index_sequence = integer_sequence<size_t, _Ip...>;
+
+#if __has_builtin(__make_integer_seq) && !defined(_LIBCUDACXX_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+
+template <class _Tp, _Tp _Ep>
+using __make_integer_sequence _LIBCUDACXX_NODEBUG_TYPE = __make_integer_seq<integer_sequence, _Tp, _Ep>;
+
+#else
+
+template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCUDACXX_NODEBUG_TYPE =
+  typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;
+
+template <class _Tp, _Tp _Ep>
+struct __make_integer_sequence_checked
+{
+    static_assert(is_integral<_Tp>::value,
+                  "std::make_integer_sequence can only be instantiated with an integral type" );
+    static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length");
+    // Workaround GCC bug by preventing bad installations when 0 <= _Ep
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929
+    typedef _LIBCUDACXX_NODEBUG_TYPE __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
+};
+
+template <class _Tp, _Tp _Ep>
+using __make_integer_sequence _LIBCUDACXX_NODEBUG_TYPE = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
+
+#endif
+
+template<class _Tp, _Tp _Np>
+    using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
+
+template<size_t _Np>
+    using make_index_sequence = make_integer_sequence<size_t, _Np>;
+
+template<class... _Tp>
+    using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_INTEGER_SEQUENCE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/move.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/move.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e351a2114742f35b1cb073a3b9c5b2497f91524
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/move.h
@@ -0,0 +1,48 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_MOVE_H
+#define _LIBCUDACXX___UTILITY_MOVE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/is_copy_constructible.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/remove_reference.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR __libcpp_remove_reference_t<_Tp>&&
+move(_Tp&& __t) _NOEXCEPT {
+  typedef _LIBCUDACXX_NODEBUG_TYPE __libcpp_remove_reference_t<_Tp> _Up;
+  return static_cast<_Up&&>(__t);
+}
+
+template <class _Tp>
+using __move_if_noexcept_result_t =
+    __conditional_t<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&&>;
+
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __move_if_noexcept_result_t<_Tp>
+move_if_noexcept(_Tp& __x) _NOEXCEPT {
+  return _CUDA_VSTD::move(__x);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_MOVE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/pair.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/pair.h
new file mode 100644
index 0000000000000000000000000000000000000000..36772f0e3bd1db820ee4d2d92433f4c0a8807c1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/pair.h
@@ -0,0 +1,864 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_PAIR_H
+#define _LIBCUDACXX___UTILITY_PAIR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+#include "../__compare/common_comparison_category.h"
+#include "../__compare/synth_three_way.h"
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+#include "../__functional/unwrap_ref.h"
+#include "../__fwd/get.h"
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/sfinae_helpers.h"
+#include "../__tuple_dir/structured_bindings.h"
+#include "../__tuple_dir/tuple_element.h"
+#include "../__tuple_dir/tuple_indices.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__type_traits/common_reference.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_assignable.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_copy_assignable.h"
+#include "../__type_traits/is_default_constructible.h"
+#include "../__type_traits/is_implicitly_default_constructible.h"
+#include "../__type_traits/is_move_assignable.h"
+#include "../__type_traits/is_nothrow_assignable.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/is_nothrow_copy_assignable.h"
+#include "../__type_traits/is_nothrow_copy_constructible.h"
+#include "../__type_traits/is_nothrow_default_constructible.h"
+#include "../__type_traits/is_nothrow_move_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_swappable.h"
+#include "../__type_traits/make_const_lvalue_ref.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+#include "../__utility/piecewise_construct.h"
+#include "../cstddef"
+
+// Provide compatability between `std::pair` and `cuda::std::pair`
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+#include <utility>
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+template <class, class>
+struct __non_trivially_copyable_base {
+  _LIBCUDACXX_CONSTEXPR _LIBCUDACXX_INLINE_VISIBILITY
+  __non_trivially_copyable_base() _NOEXCEPT {}
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+  __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
+};
+#endif
+
+template <class _T1, class _T2>
+struct _LIBCUDACXX_TEMPLATE_VIS pair
+#if defined(_LIBCUDACXX_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+: private __non_trivially_copyable_base<_T1, _T2>
+#endif
+{
+    typedef _T1 first_type;
+    typedef _T2 second_type;
+
+    _T1 first;
+    _T2 second;
+
+    pair(pair const&) = default;
+    pair(pair&&) = default;
+
+    struct _CheckArgs {
+      struct __enable_implicit_default : public integral_constant<bool,
+                 __is_implicitly_default_constructible<_T1>::value
+              && __is_implicitly_default_constructible<_T2>::value>
+      {};
+
+      struct __enable_explicit_default : public integral_constant<bool,
+                 is_default_constructible<_T1>::value
+              && is_default_constructible<_T2>::value
+              && !__enable_implicit_default::value>
+      {};
+
+      template <class _U1, class _U2>
+      struct __is_pair_constructible : public integral_constant<bool,
+                 is_constructible<first_type, _U1>::value
+              && is_constructible<second_type, _U2>::value>
+      {};
+
+      template <class _U1, class _U2>
+      struct __is_implicit : public integral_constant<bool,
+                 is_convertible<_U1, first_type>::value
+              && is_convertible<_U2, second_type>::value>
+      {};
+
+      template <class _U1, class _U2>
+      struct __enable_explicit : public integral_constant<bool,
+                 __is_pair_constructible<_U1, _U2>::value
+             && !__is_implicit<_U1, _U2>::value>
+      {};
+
+      template <class _U1, class _U2>
+      struct __enable_implicit : public integral_constant<bool,
+                 __is_pair_constructible<_U1, _U2>::value
+             &&  __is_implicit<_U1, _U2>::value>
+      {};
+    };
+
+    template <bool _MaybeEnable>
+    using _CheckArgsDep _LIBCUDACXX_NODEBUG_TYPE = __conditional_t<
+      _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>;
+
+    struct _CheckTupleLikeConstructor {
+        template <class _Tuple>
+        struct __enable_implicit : public integral_constant<bool,
+                    __tuple_convertible<_Tuple, pair>::value>
+        {};
+        template <class _Tuple>
+        struct __enable_explicit : public integral_constant<bool,
+                    __tuple_constructible<_Tuple, pair>::value
+                && !__tuple_convertible<_Tuple, pair>::value>
+        {};
+        template <class _Tuple>
+        struct __enable_assign : public integral_constant<bool,
+                    __tuple_assignable<_Tuple, pair>::value>
+        {};
+    };
+
+    template <class _Tuple>
+    using _CheckTLC _LIBCUDACXX_NODEBUG_TYPE = __conditional_t<
+        __tuple_like_with_size<_Tuple, 2>::value
+            && !is_same<__decay_t<_Tuple>, pair>::value,
+        _CheckTupleLikeConstructor,
+        __check_tuple_constructor_fail
+    >;
+
+    template<bool _Dummy = true, __enable_if_t<
+            _CheckArgsDep<_Dummy>::__enable_explicit_default::value
+    >* = nullptr>
+    explicit _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
+                      is_nothrow_default_constructible<second_type>::value)
+        : first(), second() {}
+
+    template<bool _Dummy = true, __enable_if_t<
+            _CheckArgsDep<_Dummy>::__enable_implicit_default::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
+                      is_nothrow_default_constructible<second_type>::value)
+        : first(), second() {}
+
+    template <bool _Dummy = true, __enable_if_t<
+             _CheckArgsDep<_Dummy>::template __enable_explicit<__make_const_lvalue_ref<_T1>, __make_const_lvalue_ref<_T2>>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(_T1 const& __t1, _T2 const& __t2)
+        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
+                   is_nothrow_copy_constructible<second_type>::value)
+        : first(__t1), second(__t2) {}
+
+    template<bool _Dummy = true, __enable_if_t<
+            _CheckArgsDep<_Dummy>::template __enable_implicit<__make_const_lvalue_ref<_T1>, __make_const_lvalue_ref<_T2>>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(_T1 const& __t1, _T2 const& __t2)
+        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
+                   is_nothrow_copy_constructible<second_type>::value)
+        : first(__t1), second(__t2) {}
+
+    template <
+#if _LIBCUDACXX_STD_VER > 20 // http://wg21.link/P1951
+        class _U1 = _T1, class _U2 = _T2,
+#else
+        class _U1, class _U2,
+#endif
+        __enable_if_t<_CheckArgs::template __enable_explicit<_U1, _U2>::value>* = nullptr
+    >
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(_U1&& __u1, _U2&& __u2)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
+                    is_nothrow_constructible<second_type, _U2>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__u1)), second(_CUDA_VSTD::forward<_U2>(__u2)) {}
+
+    template <
+#if _LIBCUDACXX_STD_VER > 20 // http://wg21.link/P1951
+        class _U1 = _T1, class _U2 = _T2,
+#else
+        class _U1, class _U2,
+#endif
+        __enable_if_t<_CheckArgs::template __enable_implicit<_U1, _U2>::value>* = nullptr
+    >
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(_U1&& __u1, _U2&& __u2)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
+                    is_nothrow_constructible<second_type, _U2>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__u1)), second(_CUDA_VSTD::forward<_U2>(__u2)) {}
+
+#if _LIBCUDACXX_STD_VER > 20
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<_U1&, _U2&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) pair(pair<_U1, _U2>& __p)
+        noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
+                  is_nothrow_constructible<second_type, _U2&>::value))
+        : first(__p.first), second(__p.second) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<_U1&, _U2&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HOST _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) pair(::std::pair<_U1, _U2>& __p)
+        noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
+                  is_nothrow_constructible<second_type, _U2&>::value))
+        : first(__p.first), second(__p.second) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+#endif // _LIBCUDACXX_STD_VER > 20
+
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(pair<_U1, _U2> const& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
+                    is_nothrow_constructible<second_type, _U2 const&>::value))
+        : first(__p.first), second(__p.second) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(::std::pair<_U1, _U2> const& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
+                    is_nothrow_constructible<second_type, _U2 const&>::value))
+        : first(__p.first), second(__p.second) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(pair<_U1, _U2> const& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
+                    is_nothrow_constructible<second_type, _U2 const&>::value))
+        : first(__p.first), second(__p.second) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(::std::pair<_U1, _U2> const& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
+                    is_nothrow_constructible<second_type, _U2 const&>::value))
+        : first(__p.first), second(__p.second) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_explicit<_U1, _U2>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(pair<_U1, _U2>&&__p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
+                    is_nothrow_constructible<second_type, _U2&&>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__p.first)), second(_CUDA_VSTD::forward<_U2>(__p.second)) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_explicit<_U1, _U2>::value
+    >* = nullptr>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(::std::pair<_U1, _U2>&&__p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
+                    is_nothrow_constructible<second_type, _U2&&>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__p.first)), second(_CUDA_VSTD::forward<_U2>(__p.second)) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_implicit<_U1, _U2>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(pair<_U1, _U2>&& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
+                    is_nothrow_constructible<second_type, _U2&&>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__p.first)), second(_CUDA_VSTD::forward<_U2>(__p.second)) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __enable_implicit<_U1, _U2>::value
+    >* = nullptr>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(::std::pair<_U1, _U2>&& __p)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
+                    is_nothrow_constructible<second_type, _U2&&>::value))
+        : first(_CUDA_VSTD::forward<_U1>(__p.first)), second(_CUDA_VSTD::forward<_U2>(__p.second)) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+#if _LIBCUDACXX_STD_VER > 20
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>::value)
+    pair(const pair<_U1, _U2>&& __p)
+        noexcept(is_nothrow_constructible<first_type, const _U1&&>::value &&
+                 is_nothrow_constructible<second_type, const _U2&&>::value)
+        : first(_CUDA_VSTD::move(__p.first)), second(_CUDA_VSTD::move(__p.second)) {}
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>::value
+    >* = nullptr>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HOST constexpr
+    explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>::value)
+    pair(const ::std::pair<_U1, _U2>&& __p)
+        noexcept(is_nothrow_constructible<first_type, const _U1&&>::value &&
+                 is_nothrow_constructible<second_type, const _U2&&>::value)
+        : first(_CUDA_VSTD::move(__p.first)), second(_CUDA_VSTD::move(__p.second)) {}
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+#endif // _LIBCUDACXX_STD_VER > 20
+
+    template<class _Tuple, __enable_if_t<
+            _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    explicit pair(_Tuple&& __p)
+        : first(_CUDA_VSTD::get<0>(_CUDA_VSTD::forward<_Tuple>(__p))),
+          second(_CUDA_VSTD::get<1>(_CUDA_VSTD::forward<_Tuple>(__p))) {}
+
+    template<class _Tuple, __enable_if_t<
+            _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>::value
+    >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    pair(_Tuple&& __p)
+        : first(_CUDA_VSTD::get<0>(_CUDA_VSTD::forward<_Tuple>(__p))),
+          second(_CUDA_VSTD::get<1>(_CUDA_VSTD::forward<_Tuple>(__p))) {}
+
+    template <class... _Args1, class... _Args2>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair(piecewise_construct_t __pc,
+         tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
+        _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
+                    is_nothrow_constructible<second_type, _Args2...>::value))
+        : pair(__pc, __first_args, __second_args,
+                typename __make_tuple_indices<sizeof...(_Args1)>::type(),
+                typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair& operator=(__conditional_t<
+                        is_copy_assignable<first_type>::value &&
+                        is_copy_assignable<second_type>::value,
+                    pair, __nat> const& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
+                   is_nothrow_copy_assignable<second_type>::value)
+    {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _UT1 = _T1, __enable_if_t<is_copy_assignable<_UT1>::value &&
+                                             is_copy_assignable<_T2>::value, int> = 0>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair& operator=(::std::pair<_T1, _T2> const& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
+                   is_nothrow_copy_assignable<second_type>::value)
+    {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair& operator=(__conditional_t<
+                        is_move_assignable<first_type>::value &&
+                        is_move_assignable<second_type>::value,
+                    pair, __nat>&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
+                   is_nothrow_move_assignable<second_type>::value)
+    {
+        first = _CUDA_VSTD::forward<first_type>(__p.first);
+        second = _CUDA_VSTD::forward<second_type>(__p.second);
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _UT1 = _T1, __enable_if_t<is_move_assignable<_UT1>::value &&
+                                             is_move_assignable<_T2>::value, int> = 0>
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair& operator=(::std::pair<_T1, _T2>&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
+                   is_nothrow_move_assignable<second_type>::value)
+    {
+        first = _CUDA_VSTD::forward<first_type>(__p.first);
+        second = _CUDA_VSTD::forward<second_type>(__p.second);
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+#if _LIBCUDACXX_STD_VER > 20
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    const pair& operator=(pair const& __p) const
+      noexcept(is_nothrow_copy_assignable_v<const first_type> &&
+               is_nothrow_copy_assignable_v<const second_type>)
+      requires(is_copy_assignable_v<const first_type> &&
+               is_copy_assignable_v<const second_type>) {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HOST constexpr
+    const pair& operator=(::std::pair<_T1, _T2> const& __p) const
+      noexcept(is_nothrow_copy_assignable_v<const first_type> &&
+               is_nothrow_copy_assignable_v<const second_type>)
+      requires(is_copy_assignable_v<const first_type> &&
+               is_copy_assignable_v<const second_type>) {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    const pair& operator=(pair&& __p) const
+      noexcept(is_nothrow_assignable_v<const first_type&, first_type> &&
+               is_nothrow_assignable_v<const second_type&, second_type>)
+      requires(is_assignable_v<const first_type&, first_type> &&
+               is_assignable_v<const second_type&, second_type>) {
+        first = _CUDA_VSTD::forward<first_type>(__p.first);
+        second = _CUDA_VSTD::forward<second_type>(__p.second);
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HOST constexpr
+    const pair& operator=(::std::pair<_T1, _T2>&& __p) const
+      noexcept(is_nothrow_assignable_v<const first_type&, first_type> &&
+               is_nothrow_assignable_v<const second_type&, second_type>)
+      requires(is_assignable_v<const first_type&, first_type> &&
+               is_assignable_v<const second_type&, second_type>) {
+        first = _CUDA_VSTD::forward<first_type>(__p.first);
+        second = _CUDA_VSTD::forward<second_type>(__p.second);
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    template<class _U1, class _U2>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    const pair& operator=(const pair<_U1, _U2>& __p) const
+      requires(is_assignable_v<const first_type&, const _U1&> &&
+               is_assignable_v<const second_type&, const _U2&>) {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HOST constexpr
+    const pair& operator=(const ::std::pair<_U1, _U2>& __p) const
+      requires(is_assignable_v<const first_type&, const _U1&> &&
+               is_assignable_v<const second_type&, const _U2&>) {
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+    template<class _U1, class _U2>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    const pair& operator=(pair<_U1, _U2>&& __p) const
+      requires(is_assignable_v<const first_type&, _U1> &&
+               is_assignable_v<const second_type&, _U2>) {
+        first = _CUDA_VSTD::forward<_U1>(__p.first);
+        second = _CUDA_VSTD::forward<_U2>(__p.second);
+        return *this;
+    }
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    template<class _U1, class _U2>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HOST constexpr
+    const pair& operator=(::std::pair<_U1, _U2>&& __p) const
+      requires(is_assignable_v<const first_type&, _U1> &&
+               is_assignable_v<const second_type&, _U2>) {
+        first = _CUDA_VSTD::forward<_U1>(__p.first);
+        second = _CUDA_VSTD::forward<_U2>(__p.second);
+        return *this;
+    }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+#endif // _LIBCUDACXX_STD_VER > 20
+
+    template <class _Tuple, __enable_if_t<
+            _CheckTLC<_Tuple>::template __enable_assign<_Tuple>::value
+     >* = nullptr>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair& operator=(_Tuple&& __p) {
+        first = _CUDA_VSTD::get<0>(_CUDA_VSTD::forward<_Tuple>(__p));
+        second = _CUDA_VSTD::get<1>(_CUDA_VSTD::forward<_Tuple>(__p));
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    void swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
+                                    __is_nothrow_swappable<second_type>::value)
+    {
+        using _CUDA_VSTD::swap;
+        swap(first,  __p.first);
+        swap(second, __p.second);
+    }
+
+#if _LIBCUDACXX_STD_VER > 20
+    _LIBCUDACXX_HIDE_FROM_ABI constexpr
+    void swap(const pair& __p) const
+        noexcept(__is_nothrow_swappable<const first_type>::value &&
+                 __is_nothrow_swappable<const second_type>::value)
+    {
+        using _CUDA_VSTD::swap;
+        swap(first,  __p.first);
+        swap(second, __p.second);
+    }
+#endif // _LIBCUDACXX_STD_VER > 20
+
+#if defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+    _LIBCUDACXX_HOST _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    operator ::std::pair<_T1, _T2>() const { return { first, second }; }
+#endif // defined(__cuda_std__) && !defined(__CUDACC_RTC__)
+
+private:
+
+    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair(piecewise_construct_t,
+         tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
+         __tuple_indices<_I1...>, __tuple_indices<_I2...>);
+};
+
+#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)
+template<class _T1, class _T2>
+pair(_T1, _T2) -> pair<_T1, _T2>;
+#endif // _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)
+
+// [pairs.spec], specialized algorithms
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return __x.first == __y.first && __x.second == __y.second;
+}
+
+#ifndef _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+template <class _T1, class _T2>
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+common_comparison_category_t<
+        __synth_three_way_result<_T1>,
+        __synth_three_way_result<_T2> >
+operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    if (auto __c = _CUDA_VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
+      return __c;
+    }
+    return _CUDA_VSTD::__synth_three_way(__x.second, __y.second);
+}
+
+#else // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return !(__x == __y);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return __y < __x;
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return !(__x < __y);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+bool
+operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
+{
+    return !(__y < __x);
+}
+
+#endif // _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+#if _LIBCUDACXX_STD_VER > 17
+template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual>
+    requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
+                                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
+struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> {
+    using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
+                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
+};
+
+template <class _T1, class _T2, class _U1, class _U2>
+    requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
+struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
+    using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
+};
+#endif // _LIBCUDACXX_STD_VER > 17
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+__enable_if_t
+<
+    __is_swappable<_T1>::value &&
+    __is_swappable<_T2>::value,
+    void
+>
+swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+                     _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
+                                 __is_nothrow_swappable<_T2>::value))
+{
+    __x.swap(__y);
+}
+
+#if _LIBCUDACXX_STD_VER > 20
+template <class _T1, class _T2>
+  requires (__is_swappable<const _T1>::value &&
+            __is_swappable<const _T2>::value)
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr
+void swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+{
+    __x.swap(__y);
+}
+#endif // _LIBCUDACXX_STD_VER > 20
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
+make_pair(_T1&& __t1, _T2&& __t2)
+{
+    return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
+               (_CUDA_VSTD::forward<_T1>(__t1), _CUDA_VSTD::forward<_T2>(__t2));
+}
+
+template <class _T1, class _T2>
+  struct _LIBCUDACXX_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
+    : public integral_constant<size_t, 2> {};
+
+template <size_t _Ip, class _T1, class _T2>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
+{
+    static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
+};
+
+template <class _T1, class _T2>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE _T1 type;
+};
+
+template <class _T1, class _T2>
+struct _LIBCUDACXX_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE _T2 type;
+};
+
+template <size_t _Ip> struct __get_pair;
+
+template <>
+struct __get_pair<0>
+{
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    _T1&
+    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    const _T1&
+    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    _T1&&
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _CUDA_VSTD::forward<_T1>(__p.first);}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    const _T1&&
+    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _CUDA_VSTD::forward<const _T1>(__p.first);}
+};
+
+template <>
+struct __get_pair<1>
+{
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    _T2&
+    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    const _T2&
+    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    _T2&&
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _CUDA_VSTD::forward<_T2>(__p.second);}
+
+    template <class _T1, class _T2>
+    static
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+    const _T2&&
+    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _CUDA_VSTD::forward<const _T2>(__p.second);}
+};
+
+template <size_t _Ip, class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(pair<_T1, _T2>& __p) _NOEXCEPT
+{
+    return __get_pair<_Ip>::get(__p);
+}
+
+template <size_t _Ip, class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(const pair<_T1, _T2>& __p) _NOEXCEPT
+{
+    return __get_pair<_Ip>::get(__p);
+}
+
+template <size_t _Ip, class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(pair<_T1, _T2>&& __p) _NOEXCEPT
+{
+    return __get_pair<_Ip>::get(_CUDA_VSTD::move(__p));
+}
+
+template <size_t _Ip, class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&& __p) _NOEXCEPT
+{
+    return __get_pair<_Ip>::get(_CUDA_VSTD::move(__p));
+}
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
+{
+    return __get_pair<0>::get(__p);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
+{
+    return __get_pair<0>::get(__p);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
+{
+    return __get_pair<0>::get(_CUDA_VSTD::move(__p));
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
+{
+    return __get_pair<0>::get(_CUDA_VSTD::move(__p));
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
+{
+    return __get_pair<1>::get(__p);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
+{
+    return __get_pair<1>::get(__p);
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
+{
+    return __get_pair<1>::get(_CUDA_VSTD::move(__p));
+}
+
+template <class _T1, class _T2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
+{
+    return __get_pair<1>::get(_CUDA_VSTD::move(__p));
+}
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_PAIR_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/piecewise_construct.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/piecewise_construct.h
new file mode 100644
index 0000000000000000000000000000000000000000..40079a9e92dee2960f4f69ed57bfac2e044f6230
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/piecewise_construct.h
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_PIECEWISE_CONSTRUCT_H
+#define _LIBCUDACXX___UTILITY_PIECEWISE_CONSTRUCT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct _LIBCUDACXX_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };
+#if defined(_LIBCUDACXX_CXX03_LANG) || defined(_LIBCUDACXX_BUILDING_LIBRARY)
+extern _LIBCUDACXX_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
+#else
+/* _LIBCUDACXX_INLINE_VAR */ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_PIECEWISE_CONSTRUCT_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/priority_tag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/priority_tag.h
new file mode 100644
index 0000000000000000000000000000000000000000..09898c5362bd9cebe61dccff4ab766a3a719b087
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/priority_tag.h
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_PRIORITY_TAG_H
+#define _LIBCUDACXX___UTILITY_PRIORITY_TAG_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template<size_t _Ip> struct __priority_tag : __priority_tag<_Ip - 1> {};
+template<> struct __priority_tag<0> {};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_PRIORITY_TAG_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/rel_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/rel_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..72f9560906301eaa2886595f0a12a08e194aa10a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/rel_ops.h
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_REL_OPS_H
+#define _LIBCUDACXX___UTILITY_REL_OPS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+namespace rel_ops
+{
+
+template<class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const _Tp& __x, const _Tp& __y)
+{
+    return !(__x == __y);
+}
+
+template<class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator> (const _Tp& __x, const _Tp& __y)
+{
+    return __y < __x;
+}
+
+template<class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator<=(const _Tp& __x, const _Tp& __y)
+{
+    return !(__y < __x);
+}
+
+template<class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator>=(const _Tp& __x, const _Tp& __y)
+{
+    return !(__x < __y);
+}
+
+} // namespace rel_ops
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_REL_OPS_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..e68295e60df8bdf8fea33f27b97f72db8071460d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/swap.h
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_SWAP_H
+#define _LIBCUDACXX___UTILITY_SWAP_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_move_assignable.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__type_traits/is_nothrow_move_assignable.h"
+#include "../__type_traits/is_nothrow_move_constructible.h"
+#include "../__type_traits/is_swappable.h"
+#include "../__utility/move.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+__swap_result_t<_Tp>
+swap(_Tp& __x, _Tp& __y) noexcept(_LIBCUDACXX_TRAIT(is_nothrow_move_constructible, _Tp)
+                               && _LIBCUDACXX_TRAIT(is_nothrow_move_assignable, _Tp)) {
+  _Tp __t(_CUDA_VSTD::move(__x));
+  __x = _CUDA_VSTD::move(__y);
+  __y = _CUDA_VSTD::move(__t);
+}
+
+template <class _Tp, size_t _Np>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+__enable_if_t<__is_swappable<_Tp>::value>
+swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) noexcept(__is_nothrow_swappable<_Tp>::value) {
+  for (size_t __i = 0; __i != _Np; ++__i) {
+    swap(__a[__i], __b[__i]);
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_SWAP_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/to_underlying.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/to_underlying.h
new file mode 100644
index 0000000000000000000000000000000000000000..10c86b2964b3915e9ca8a9849090b3b3ff41a4ec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/to_underlying.h
@@ -0,0 +1,44 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_TO_UNDERLYING_H
+#define _LIBCUDACXX___UTILITY_TO_UNDERLYING_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/underlying_type.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY constexpr typename underlying_type<_Tp>::type
+__to_underlying(_Tp __val) noexcept {
+  return static_cast<typename underlying_type<_Tp>::type>(__val);
+}
+#endif // !_LIBCUDACXX_CXX03_LANG
+
+#if _LIBCUDACXX_STD_VER > 20
+template <class _Tp>
+_LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY constexpr underlying_type_t<_Tp>
+to_underlying(_Tp __val) noexcept {
+  return _CUDA_VSTD::__to_underlying(__val);
+}
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___UTILITY_TO_UNDERLYING_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/unreachable.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/unreachable.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a136921b677a7dad852b87ad8ecaf5bac6ed9d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/__utility/unreachable.h
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___UTILITY_UNREACHABLE_H
+#define _LIBCUDACXX___UTILITY_UNREACHABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstdlib"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_NORETURN _LIBCUDACXX_INLINE_VISIBILITY
+inline void __libcpp_unreachable()
+{
+  _LIBCUDACXX_UNREACHABLE();
+}
+
+#if _LIBCUDACXX_STD_VER > 20
+
+[[noreturn]] _LIBCUDACXX_INLINE_VISIBILITY
+inline void unreachable() { _LIBCUDACXX_UNREACHABLE(); }
+
+#endif // _LIBCUDACXX_STD_VER > 20
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__config b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__config
new file mode 100644
index 0000000000000000000000000000000000000000..4571a089240044592066777222f6cd9cdc767824
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__config
@@ -0,0 +1,79 @@
+// -*- C++ -*-
+//===--------------------------- __config ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_CONFIG
+#define _LIBCUDACXX_EXPERIMENTAL_CONFIG
+
+#include <__config>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental {
+#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL  } }
+#define _CUDA_VSTD_EXPERIMENTAL std::experimental
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 {
+#define _LIBCUDACXX_END_NAMESPACE_LFTS  } } }
+#define _CUDA_VSTD_LFTS _CUDA_VSTD_EXPERIMENTAL::fundamentals_v1
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS_V2 _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
+#define _LIBCUDACXX_END_NAMESPACE_LFTS_V2  } } }
+#define _CUDA_VSTD_LFTS_V2 _CUDA_VSTD_EXPERIMENTAL::fundamentals_v2
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR _LIBCUDACXX_BEGIN_NAMESPACE_LFTS namespace pmr {
+#define _LIBCUDACXX_END_NAMESPACE_LFTS_PMR _LIBCUDACXX_END_NAMESPACE_LFTS }
+#define _CUDA_VSTD_LFTS_PMR _CUDA_VSTD_LFTS::pmr
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCUDACXX_BEGIN_NAMESPACE_STD        \
+  namespace chrono { namespace experimental { inline namespace fundamentals_v1 {
+#define _LIBCUDACXX_END_NAMESPACE_CHRONO_LFTS _LIBCUDACXX_END_NAMESPACE_STD } } }
+
+#if defined(_LIBCUDACXX_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM)
+#   define _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM /* nothing */
+#else
+#   define _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM __attribute__((deprecated("std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCUDACXX_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro.")))
+#endif
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
+    _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCUDACXX_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \
+    inline namespace v1 {
+
+#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
+    } } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \
+  _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 {
+
+#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_COROUTINES \
+  } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL
+
+#define _CUDA_VSTD_CORO _CUDA_VSTD_EXPERIMENTAL::coroutines_v1
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
+    _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
+
+#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD \
+    } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
+    _LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {
+
+#define _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
+    } _LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD
+
+// TODO: support more targets
+#if defined(__AVX__)
+#define _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES 32
+#else
+#define _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES 16
+#endif
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__memory b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__memory
new file mode 100644
index 0000000000000000000000000000000000000000..db27511e7450ab5f93549183c0de3601393d251b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/__memory
@@ -0,0 +1,89 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL___MEMORY
+#define _LIBCUDACXX_EXPERIMENTAL___MEMORY
+
+#include <experimental/__config>
+#include <experimental/utility> // for erased_type
+#include <__functional_base>
+#include <type_traits>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+template <
+    class _Tp, class _Alloc
+  , bool = uses_allocator<_Tp, _Alloc>::value
+  , bool = __has_allocator_type<_Tp>::value
+  >
+struct __lfts_uses_allocator : public false_type {};
+
+template <class _Tp, class _Alloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {};
+
+template <class _Tp, class _Alloc, bool HasAlloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {};
+
+template <class _Tp, class _Alloc>
+struct __lfts_uses_allocator<_Tp, _Alloc, false, true>
+  : public integral_constant<bool
+    , is_convertible<_Alloc, typename _Tp::allocator_type>::value
+      || is_same<erased_type, typename _Tp::allocator_type>::value
+    >
+{};
+
+template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor_imp
+{
+    static const int value = 0;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...>
+{
+    static const bool __ic_first
+        = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+
+    static const bool __ic_second =
+        conditional<
+            __ic_first,
+            false_type,
+            is_constructible<_Tp, _Args..., _Alloc>
+        >::type::value;
+
+    static_assert(__ic_first || __ic_second,
+                  "Request for uses allocator construction is ill-formed");
+
+    static const int value = __ic_first ? 1 : 2;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __lfts_uses_alloc_ctor
+  : integral_constant<int,
+        __lfts_uses_alloc_ctor_imp<
+            __lfts_uses_allocator<_Tp, _Alloc>::value
+          , _Tp, _Alloc, _Args...
+        >::value
+    >
+{};
+
+template <class _Tp, class _Alloc, class ..._Args>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void __lfts_user_alloc_construct(
+    _Tp * __store, const _Alloc & __a, _Args &&... __args)
+{
+    _CUDA_VSTD::__user_alloc_construct_impl(
+        typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type()
+       , __store, __a, _CUDA_VSTD::forward<_Args>(__args)...
+       );
+}
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL___MEMORY */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm
new file mode 100644
index 0000000000000000000000000000000000000000..7fe305cf0b47ec196cb33d4a82ab46c61dedde7f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/algorithm
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+//===-------------------------- algorithm ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_ALGORITHM
+#define _LIBCUDACXX_EXPERIMENTAL_ALGORITHM
+
+/*
+   experimental/algorithm synopsis
+
+#include <algorithm>
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+
+template <class ForwardIterator, class Searcher>
+ForwardIterator search(ForwardIterator first, ForwardIterator last,
+                       const Searcher &searcher);
+
+// sample removed because it's now part of C++17
+
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#include <algorithm>
+#include <type_traits>
+
+#include <__debug>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+template <class _ForwardIterator, class _Searcher>
+_LIBCUDACXX_INLINE_VISIBILITY
+_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
+{ return __s(__f, __l).first; }
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+_LIBCUDACXX_POP_MACROS
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_ALGORITHM */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine
new file mode 100644
index 0000000000000000000000000000000000000000..a6b5c5838fd008d8217ba907646a1be951cd56ca
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/coroutine
@@ -0,0 +1,334 @@
+// -*- C++ -*-
+//===----------------------------- coroutine -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_COROUTINE
+#define _LIBCUDACXX_EXPERIMENTAL_COROUTINE
+
+/**
+    experimental/coroutine synopsis
+
+// C++next
+
+namespace std {
+namespace experimental {
+inline namespace coroutines_v1 {
+
+  // 18.11.1 coroutine traits
+template <typename R, typename... ArgTypes>
+class coroutine_traits;
+// 18.11.2 coroutine handle
+template <typename Promise = void>
+class coroutine_handle;
+// 18.11.2.7 comparison operators:
+bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
+// 18.11.3 trivial awaitables
+struct suspend_never;
+struct suspend_always;
+// 18.11.2.8 hash support:
+template <class T> struct hash;
+template <class P> struct hash<coroutine_handle<P>>;
+
+} // namespace coroutines_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <new>
+#include <type_traits>
+#include <functional>
+#include <memory> // for hash<T*>
+#include <cstddef>
+#include <__debug>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#ifdef _LIBCUDACXX_HAS_NO_COROUTINES
+# if defined(_LIBCUDACXX_WARNING)
+    _LIBCUDACXX_WARNING("<experimental/coroutine> cannot be used with this compiler")
+# else
+#   warning <experimental/coroutine> cannot be used with this compiler
+# endif
+#endif
+
+#ifndef _LIBCUDACXX_HAS_NO_COROUTINES
+
+_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
+
+template <class _Tp, class = void>
+struct __coroutine_traits_sfinae {};
+
+template <class _Tp>
+struct __coroutine_traits_sfinae<
+    _Tp, __void_t<typename _Tp::promise_type>>
+{
+  using promise_type = typename _Tp::promise_type;
+};
+
+template <typename _Ret, typename... _Args>
+struct coroutine_traits
+    : public __coroutine_traits_sfinae<_Ret>
+{
+};
+
+template <typename _Promise = void>
+class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle;
+
+template <>
+class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle<void> {
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
+        __handle_ = nullptr;
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void operator()() { resume(); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void resume() {
+      _LIBCUDACXX_ASSERT(__is_suspended(),
+                     "resume() can only be called on suspended coroutines");
+      _LIBCUDACXX_ASSERT(!done(),
+                "resume() has undefined behavior when the coroutine is done");
+      __builtin_coro_resume(__handle_);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void destroy() {
+      _LIBCUDACXX_ASSERT(__is_suspended(),
+                     "destroy() can only be called on suspended coroutines");
+      __builtin_coro_destroy(__handle_);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool done() const {
+      _LIBCUDACXX_ASSERT(__is_suspended(),
+                     "done() can only be called on suspended coroutines");
+      return __builtin_coro_done(__handle_);
+    }
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static coroutine_handle from_address(void* __addr) _NOEXCEPT {
+        coroutine_handle __tmp;
+        __tmp.__handle_ = __addr;
+        return __tmp;
+    }
+
+    // FIXME: Should from_address(nullptr) be allowed?
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
+      return coroutine_handle(nullptr);
+    }
+
+    template <class _Tp, bool _CallIsValid = false>
+    static coroutine_handle from_address(_Tp*) {
+      static_assert(_CallIsValid,
+       "coroutine_handle<void>::from_address cannot be called with "
+        "non-void pointers");
+    }
+
+private:
+  bool __is_suspended() const _NOEXCEPT  {
+    // FIXME actually implement a check for if the coro is suspended.
+    return __handle_;
+  }
+
+  template <class _PromiseT> friend class coroutine_handle;
+  void* __handle_;
+};
+
+// 18.11.2.7 comparison operators:
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return __x.address() == __y.address();
+}
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return !(__x == __y);
+}
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return less<void*>()(__x.address(), __y.address());
+}
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return __y < __x;
+}
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return !(__x > __y);
+}
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
+    return !(__x < __y);
+}
+
+template <typename _Promise>
+class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> {
+    using _Base = coroutine_handle<>;
+public:
+#ifndef _LIBCUDACXX_CXX03_LANG
+    // 18.11.2.1 construct/reset
+    using coroutine_handle<>::coroutine_handle;
+#else
+    _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {}
+    _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {}
+#endif
+    _LIBCUDACXX_INLINE_VISIBILITY
+    coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
+        _Base::operator=(nullptr);
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _Promise& promise() const {
+        return *static_cast<_Promise*>(
+            __builtin_coro_promise(this->__handle_, _LIBCUDACXX_ALIGNOF(_Promise), false));
+    }
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static coroutine_handle from_address(void* __addr) _NOEXCEPT {
+        coroutine_handle __tmp;
+        __tmp.__handle_ = __addr;
+        return __tmp;
+    }
+
+    // NOTE: this overload isn't required by the standard but is needed so
+    // the deleted _Promise* overload doesn't make from_address(nullptr)
+    // ambiguous.
+    // FIXME: should from_address work with nullptr?
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
+      return coroutine_handle(nullptr);
+    }
+
+    template <class _Tp, bool _CallIsValid = false>
+    static coroutine_handle from_address(_Tp*) {
+      static_assert(_CallIsValid,
+       "coroutine_handle<promise_type>::from_address cannot be called with "
+        "non-void pointers");
+    }
+
+    template <bool _CallIsValid = false>
+    static coroutine_handle from_address(_Promise*) {
+      static_assert(_CallIsValid,
+       "coroutine_handle<promise_type>::from_address cannot be used with "
+        "pointers to the coroutine's promise type; use 'from_promise' instead");
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
+        typedef __remove_cv_t<_Promise> _RawPromise;
+        coroutine_handle __tmp;
+        __tmp.__handle_ = __builtin_coro_promise(
+            _CUDA_VSTD::addressof(const_cast<_RawPromise&>(__promise)),
+             _LIBCUDACXX_ALIGNOF(_Promise), true);
+        return __tmp;
+    }
+};
+
+#if __has_builtin(__builtin_coro_noop)
+struct noop_coroutine_promise {};
+
+template <>
+class _LIBCUDACXX_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise>
+    : public coroutine_handle<> {
+  using _Base = coroutine_handle<>;
+  using _Promise = noop_coroutine_promise;
+public:
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  _Promise& promise() const {
+    return *static_cast<_Promise*>(
+      __builtin_coro_promise(this->__handle_, _LIBCUDACXX_ALIGNOF(_Promise), false));
+  }
+
+  _LIBCUDACXX_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
+  _LIBCUDACXX_CONSTEXPR bool done() const _NOEXCEPT { return false; }
+
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {}
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {}
+  _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {}
+
+private:
+  _LIBCUDACXX_INLINE_VISIBILITY
+  friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
+
+  _LIBCUDACXX_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
+    this->__handle_ = __builtin_coro_noop();
+  }
+};
+
+using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+noop_coroutine_handle noop_coroutine() _NOEXCEPT {
+  return noop_coroutine_handle();
+}
+#endif // __has_builtin(__builtin_coro_noop)
+
+struct suspend_never {
+  _LIBCUDACXX_INLINE_VISIBILITY
+  bool await_ready() const _NOEXCEPT { return true; }
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void await_resume() const _NOEXCEPT {}
+};
+
+struct suspend_always {
+  _LIBCUDACXX_INLINE_VISIBILITY
+  bool await_ready() const _NOEXCEPT { return false; }
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void await_resume() const _NOEXCEPT {}
+};
+
+_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_COROUTINES
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash<_CUDA_VSTD_CORO::coroutine_handle<_Tp> > {
+    using __arg_type = _CUDA_VSTD_CORO::coroutine_handle<_Tp>;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(__arg_type const& __v) const _NOEXCEPT
+    {return hash<void*>()(__v.address());}
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCUDACXX_HAS_NO_COROUTINES)
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_COROUTINE */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/deque b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/deque
new file mode 100644
index 0000000000000000000000000000000000000000..1f2291796db96da200a245a65263f23cdee529b0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/deque
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===--------------------------- deque ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_DEQUE
+#define _LIBCUDACXX_EXPERIMENTAL_DEQUE
+/*
+    experimental/deque synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using deque = std::deque<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <deque>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using deque = _CUDA_VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_DEQUE */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/filesystem b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/filesystem
new file mode 100644
index 0000000000000000000000000000000000000000..2b0d1dba70fabaf05863cb113e43d66e28e5fbcf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/filesystem
@@ -0,0 +1,256 @@
+// -*- C++ -*-
+//===--------------------------- filesystem -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX_EXPERIMENTAL_FILESYSTEM
+#define _LIBCUDACXX_EXPERIMENTAL_FILESYSTEM
+/*
+    filesystem synopsis
+
+    namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
+
+    class path;
+
+    void swap(path& lhs, path& rhs) noexcept;
+    size_t hash_value(const path& p) noexcept;
+
+    bool operator==(const path& lhs, const path& rhs) noexcept;
+    bool operator!=(const path& lhs, const path& rhs) noexcept;
+    bool operator< (const path& lhs, const path& rhs) noexcept;
+    bool operator<=(const path& lhs, const path& rhs) noexcept;
+    bool operator> (const path& lhs, const path& rhs) noexcept;
+    bool operator>=(const path& lhs, const path& rhs) noexcept;
+
+    path operator/ (const path& lhs, const path& rhs);
+
+    // fs.path.io operators are friends of path.
+    template <class charT, class traits>
+    friend basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const path& p);
+
+    template <class charT, class traits>
+    friend basic_istream<charT, traits>&
+    operator>>(basic_istream<charT, traits>& is, path& p);
+
+    template <class Source>
+      path u8path(const Source& source);
+    template <class InputIterator>
+      path u8path(InputIterator first, InputIterator last);
+
+    class filesystem_error;
+    class directory_entry;
+
+    class directory_iterator;
+
+    // enable directory_iterator range-based for statements
+    directory_iterator begin(directory_iterator iter) noexcept;
+    directory_iterator end(const directory_iterator&) noexcept;
+
+    class recursive_directory_iterator;
+
+    // enable recursive_directory_iterator range-based for statements
+    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+    recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
+
+    class file_status;
+
+    struct space_info
+    {
+      uintmax_t capacity;
+      uintmax_t free;
+      uintmax_t available;
+    };
+
+    enum class file_type;
+    enum class perms;
+    enum class perm_options;
+    enum class copy_options;
+    enum class directory_options;
+
+    typedef chrono::time_point<trivial-clock>  file_time_type;
+
+    // operational functions
+
+    path absolute(const path& p);
+    path absolute(const path& p, error_code &ec);
+
+    path canonical(const path& p);
+    path canonical(const path& p, error_code& ec);
+
+    void copy(const path& from, const path& to);
+    void copy(const path& from, const path& to, error_code& ec);
+    void copy(const path& from, const path& to, copy_options options);
+    void copy(const path& from, const path& to, copy_options options,
+                   error_code& ec);
+
+    bool copy_file(const path& from, const path& to);
+    bool copy_file(const path& from, const path& to, error_code& ec);
+    bool copy_file(const path& from, const path& to, copy_options option);
+    bool copy_file(const path& from, const path& to, copy_options option,
+                           error_code& ec);
+
+    void copy_symlink(const path& existing_symlink, const path& new_symlink);
+    void copy_symlink(const path& existing_symlink, const path& new_symlink,
+                              error_code& ec) noexcept;
+
+    bool create_directories(const path& p);
+    bool create_directories(const path& p, error_code& ec);
+
+    bool create_directory(const path& p);
+    bool create_directory(const path& p, error_code& ec) noexcept;
+
+    bool create_directory(const path& p, const path& attributes);
+    bool create_directory(const path& p, const path& attributes,
+                                  error_code& ec) noexcept;
+
+    void create_directory_symlink(const path& to, const path& new_symlink);
+    void create_directory_symlink(const path& to, const path& new_symlink,
+                                          error_code& ec) noexcept;
+
+    void create_hard_link(const path& to, const path& new_hard_link);
+    void create_hard_link(const path& to, const path& new_hard_link,
+                                  error_code& ec) noexcept;
+
+    void create_symlink(const path& to, const path& new_symlink);
+    void create_symlink(const path& to, const path& new_symlink,
+                                error_code& ec) noexcept;
+
+    path current_path();
+    path current_path(error_code& ec);
+    void current_path(const path& p);
+    void current_path(const path& p, error_code& ec) noexcept;
+
+    bool exists(file_status s) noexcept;
+    bool exists(const path& p);
+    bool exists(const path& p, error_code& ec) noexcept;
+
+    bool equivalent(const path& p1, const path& p2);
+    bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
+
+    uintmax_t    file_size(const path& p);
+    uintmax_t    file_size(const path& p, error_code& ec) noexcept;
+
+    uintmax_t    hard_link_count(const path& p);
+    uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;
+
+    bool is_block_file(file_status s) noexcept;
+    bool is_block_file(const path& p);
+    bool is_block_file(const path& p, error_code& ec) noexcept;
+
+    bool is_character_file(file_status s) noexcept;
+    bool is_character_file(const path& p);
+    bool is_character_file(const path& p, error_code& ec) noexcept;
+
+    bool is_directory(file_status s) noexcept;
+    bool is_directory(const path& p);
+    bool is_directory(const path& p, error_code& ec) noexcept;
+
+    bool is_empty(const path& p);
+    bool is_empty(const path& p, error_code& ec) noexcept;
+
+    bool is_fifo(file_status s) noexcept;
+    bool is_fifo(const path& p);
+    bool is_fifo(const path& p, error_code& ec) noexcept;
+
+    bool is_other(file_status s) noexcept;
+    bool is_other(const path& p);
+    bool is_other(const path& p, error_code& ec) noexcept;
+
+    bool is_regular_file(file_status s) noexcept;
+    bool is_regular_file(const path& p);
+    bool is_regular_file(const path& p, error_code& ec) noexcept;
+
+    bool is_socket(file_status s) noexcept;
+    bool is_socket(const path& p);
+    bool is_socket(const path& p, error_code& ec) noexcept;
+
+    bool is_symlink(file_status s) noexcept;
+    bool is_symlink(const path& p);
+    bool is_symlink(const path& p, error_code& ec) noexcept;
+
+    file_time_type  last_write_time(const path& p);
+    file_time_type  last_write_time(const path& p, error_code& ec) noexcept;
+    void last_write_time(const path& p, file_time_type new_time);
+    void last_write_time(const path& p, file_time_type new_time,
+                                 error_code& ec) noexcept;
+
+    void permissions(const path& p, perms prms,
+                     perm_options opts=perm_options::replace);
+    void permissions(const path& p, perms prms, error_code& ec) noexcept;
+    void permissions(const path& p, perms prms, perm_options opts,
+                     error_code& ec);
+
+    path proximate(const path& p, error_code& ec);
+    path proximate(const path& p, const path& base = current_path());
+    path proximate(const path& p, const path& base, error_code &ec);
+
+    path read_symlink(const path& p);
+    path read_symlink(const path& p, error_code& ec);
+
+    path relative(const path& p, error_code& ec);
+    path relative(const path& p, const path& base=current_path());
+    path relative(const path& p, const path& base, error_code& ec);
+
+    bool remove(const path& p);
+    bool remove(const path& p, error_code& ec) noexcept;
+
+    uintmax_t    remove_all(const path& p);
+    uintmax_t    remove_all(const path& p, error_code& ec);
+
+    void rename(const path& from, const path& to);
+    void rename(const path& from, const path& to, error_code& ec) noexcept;
+
+    void resize_file(const path& p, uintmax_t size);
+    void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
+
+    space_info   space(const path& p);
+    space_info   space(const path& p, error_code& ec) noexcept;
+
+    file_status  status(const path& p);
+    file_status  status(const path& p, error_code& ec) noexcept;
+
+    bool status_known(file_status s) noexcept;
+
+    file_status  symlink_status(const path& p);
+    file_status  symlink_status(const path& p, error_code& ec) noexcept;
+
+    path temp_directory_path();
+    path temp_directory_path(error_code& ec);
+
+    path weakly_canonical(path const& p);
+    path weakly_canonical(path const& p, error_code& ec);
+
+
+} } } }  // namespaces std::experimental::filesystem::v1
+
+*/
+
+#include <experimental/__config>
+#include <filesystem>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+
+#define __cpp_lib_experimental_filesystem 201406
+
+_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+using namespace _CUDA_VSTD_FS;
+
+_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+#endif // !_LIBCUDACXX_CXX03_LANG
+
+_LIBCUDACXX_POP_MACROS
+
+#endif // _LIBCUDACXX_EXPERIMENTAL_FILESYSTEM
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list
new file mode 100644
index 0000000000000000000000000000000000000000..585ca5a8d6fc9fa262c7a214c86dbf86b921297e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/forward_list
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===--------------------------- forward_list -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST
+#define _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST
+/*
+    experimental/forward_list synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <forward_list>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using forward_list = _CUDA_VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_FORWARD_LIST */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/functional b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/functional
new file mode 100644
index 0000000000000000000000000000000000000000..719396c07c7b6d9f79d5dedd509d740f446b92e0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/functional
@@ -0,0 +1,458 @@
+// -*- C++ -*-
+//===-------------------------- functional --------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL
+#define _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL
+
+/*
+   experimental/functional synopsis
+
+#include <algorithm>
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+
+    // See C++14 20.9.9, Function object binders
+    template <class T> constexpr bool is_bind_expression_v
+      = is_bind_expression<T>::value;
+    template <class T> constexpr int is_placeholder_v
+      = is_placeholder<T>::value;
+
+    // 4.2, Class template function
+    template<class> class function; // undefined
+    template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
+
+    template<class R, class... ArgTypes>
+    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+
+    template<class R, class... ArgTypes>
+    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+    template<class R, class... ArgTypes>
+    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+    template<class R, class... ArgTypes>
+    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+    template<class R, class... ArgTypes>
+    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+
+    // 4.3, Searchers
+    template<class ForwardIterator, class BinaryPredicate = equal_to<>>
+      class default_searcher;
+
+    template<class RandomAccessIterator,
+             class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
+             class BinaryPredicate = equal_to<>>
+      class boyer_moore_searcher;
+
+    template<class RandomAccessIterator,
+             class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
+             class BinaryPredicate = equal_to<>>
+      class boyer_moore_horspool_searcher;
+
+    template<class ForwardIterator, class BinaryPredicate = equal_to<>>
+    default_searcher<ForwardIterator, BinaryPredicate>
+    make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
+                          BinaryPredicate pred = BinaryPredicate());
+
+    template<class RandomAccessIterator,
+             class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
+             class BinaryPredicate = equal_to<>>
+    boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
+    make_boyer_moore_searcher(
+        RandomAccessIterator pat_first, RandomAccessIterator pat_last,
+        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
+
+    template<class RandomAccessIterator,
+             class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
+             class BinaryPredicate = equal_to<>>
+    boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
+    make_boyer_moore_horspool_searcher(
+        RandomAccessIterator pat_first, RandomAccessIterator pat_last,
+        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
+
+  } // namespace fundamentals_v1
+  } // namespace experimental
+
+  template<class R, class... ArgTypes, class Alloc>
+  struct uses_allocator<experimental::function<R(ArgTypes...)>, Alloc>;
+
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#include <functional>
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+#include <array>
+#include <unordered_map>
+
+#include <__debug>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+#if _LIBCUDACXX_STD_VER > 11
+// default searcher
+template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
+class _LIBCUDACXX_TYPE_VIS default_searcher {
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    default_searcher(_ForwardIterator __f, _ForwardIterator __l, 
+                       _BinaryPredicate __p = _BinaryPredicate())
+        : __first_(__f), __last_(__l), __pred_(__p) {}
+
+    template <typename _ForwardIterator2>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    pair<_ForwardIterator2, _ForwardIterator2>
+    operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
+    {
+        return _CUDA_VSTD::__search(__f, __l, __first_, __last_, __pred_,
+            typename _CUDA_VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
+            typename _CUDA_VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
+    }
+
+private:
+    _ForwardIterator __first_;
+    _ForwardIterator __last_;
+    _BinaryPredicate __pred_;
+    };
+
+template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
+_LIBCUDACXX_INLINE_VISIBILITY
+default_searcher<_ForwardIterator, _BinaryPredicate>
+make_default_searcher( _ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate ())
+{
+    return default_searcher<_ForwardIterator, _BinaryPredicate>(__f, __l, __p);
+}
+
+template<class _Key, class _Value, class _Hash, class _BinaryPredicate, bool /*useArray*/> class _BMSkipTable;
+
+//  General case for BM data searching; use a map
+template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
+class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> {
+public: // TODO private:
+    typedef _Value value_type;
+    typedef _Key   key_type;
+
+    const _Value __default_value_;
+    std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table;
+    
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _BMSkipTable(std::size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred)
+        : __default_value_(__default), __table(__sz, __hf, __pred) {}
+    
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void insert(const key_type &__key, value_type __val)
+    {
+        __table [__key] = __val;    // Would skip_.insert (val) be better here?
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    value_type operator [](const key_type & __key) const
+    {
+        auto __it = __table.find (__key);
+        return __it == __table.end() ? __default_value_ : __it->second;
+    }
+};
+    
+
+//  Special case small numeric values; use an array
+template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
+class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> {
+private:
+    typedef _Value value_type;
+    typedef _Key   key_type;
+
+    typedef typename std::make_unsigned<key_type>::type unsigned_key_type;
+    typedef std::array<value_type, _CUDA_VSTD::numeric_limits<unsigned_key_type>::max()> skip_map;
+    skip_map __table;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _BMSkipTable(std::size_t /*__sz*/, _Value __default, _Hash /*__hf*/, _BinaryPredicate /*__pred*/)
+    {
+        std::fill_n(__table.begin(), __table.size(), __default);
+    }
+    
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void insert(key_type __key, value_type __val)
+    {
+        __table[static_cast<unsigned_key_type>(__key)] = __val;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    value_type operator [](key_type __key) const
+    {
+        return __table[static_cast<unsigned_key_type>(__key)];
+    }
+};
+
+
+template <class _RandomAccessIterator1, 
+          class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, 
+          class _BinaryPredicate = equal_to<>>
+class _LIBCUDACXX_TYPE_VIS boyer_moore_searcher {
+private:
+    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type;
+    typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type      value_type;
+    typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate,
+                    _CUDA_VSTD::is_integral<value_type>::value && // what about enums?
+                    sizeof(value_type) == 1 &&
+                    is_same<_Hash, hash<value_type>>::value &&
+                    is_same<_BinaryPredicate, equal_to<>>::value
+            > skip_table_type;
+    
+public:
+    boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, 
+                _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
+            : __first_(__f), __last_(__l), __pred_(__pred),
+              __pattern_length_(_CUDA_VSTD::distance(__first_, __last_)),
+              __skip_{make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)},
+              __suffix_{make_shared<vector<difference_type>>(__pattern_length_ + 1)}
+        {
+    //  build the skip table
+        for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i )
+            __skip_->insert(*__f, __i);
+
+        this->__build_suffix_table ( __first_, __last_, __pred_ );
+        }
+        
+    template <typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
+    {
+        static_assert ( std::is_same<
+                std::__remove_cvref_t<typename std::iterator_traits<_RandomAccessIterator1>::value_type>, 
+                std::__remove_cvref_t<typename std::iterator_traits<_RandomAccessIterator2>::value_type>
+                    >::value,
+                "Corpus and Pattern iterators must point to the same type" );
+
+        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
+
+    //  If the pattern is larger than the corpus, we can't find it!
+        if ( __pattern_length_ > _CUDA_VSTD::distance (__f, __l)) 
+            return make_pair(__l, __l);
+
+    //  Do the search 
+        return this->__search(__f, __l);
+    }
+        
+public: // TODO private:
+    _RandomAccessIterator1               __first_;
+    _RandomAccessIterator1               __last_;
+    _BinaryPredicate                     __pred_;
+    difference_type                      __pattern_length_;
+    shared_ptr<skip_table_type>          __skip_;
+    shared_ptr<vector<difference_type>>  __suffix_;
+
+    template <typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
+    {
+        _RandomAccessIterator2 __cur = __f;
+        const _RandomAccessIterator2 __last = __l - __pattern_length_;
+        const skip_table_type &         __skip   = *__skip_.get();
+        const vector<difference_type> & __suffix = *__suffix_.get();
+        
+        while (__cur <= __last)
+        {
+
+        //  Do we match right where we are?
+            difference_type __j = __pattern_length_;
+            while (__pred_(__first_ [__j-1], __cur [__j-1])) {
+                __j--;
+            //  We matched - we're done!
+                if ( __j == 0 )
+                    return make_pair(__cur, __cur + __pattern_length_);
+                }
+            
+        //  Since we didn't match, figure out how far to skip forward
+            difference_type __k = __skip[__cur [ __j - 1 ]];
+            difference_type __m = __j - __k - 1;
+            if (__k < __j && __m > __suffix[ __j ])
+                __cur += __m;
+            else
+                __cur += __suffix[ __j ];
+        }
+    
+        return make_pair(__l, __l);     // We didn't find anything
+    }
+
+
+    template<typename _Iterator, typename _Container>
+    void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix )
+    {
+        const std::size_t __count = _CUDA_VSTD::distance(__f, __l);
+                        
+        __prefix[0] = 0;
+        std::size_t __k = 0;
+        for ( std::size_t __i = 1; __i < __count; ++__i )
+        {
+            while ( __k > 0 && !__pred ( __f[__k], __f[__i] ))
+                __k = __prefix [ __k - 1 ];
+                
+            if ( __pred ( __f[__k], __f[__i] ))
+                __k++;
+            __prefix [ __i ] = __k;
+        }
+    }
+
+    void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, 
+                                                    _BinaryPredicate __pred)
+    {
+        const std::size_t __count = _CUDA_VSTD::distance(__f, __l);
+        vector<difference_type> & __suffix = *__suffix_.get();
+        if (__count > 0)
+        {
+            _CUDA_VSTD::vector<value_type> __scratch(__count);
+            
+            __compute_bm_prefix(__f, __l, __pred, __scratch);
+            for ( std::size_t __i = 0; __i <= __count; __i++ )
+                __suffix[__i] = __count - __scratch[__count-1];
+    
+            typedef _CUDA_VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter;
+            __compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch);
+     
+            for ( std::size_t __i = 0; __i < __count; __i++ )
+            {
+                const std::size_t     __j = __count - __scratch[__i];
+                const difference_type __k = __i     - __scratch[__i] + 1;
+     
+                if (__suffix[__j] > __k)
+                    __suffix[__j] = __k;
+            }
+        }
+    }
+
+};
+
+template<class _RandomAccessIterator, 
+         class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>, 
+         class _BinaryPredicate = equal_to<>>
+_LIBCUDACXX_INLINE_VISIBILITY
+boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
+make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, 
+                    _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
+{
+    return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
+}
+
+// boyer-moore-horspool
+template <class _RandomAccessIterator1, 
+          class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>, 
+          class _BinaryPredicate = equal_to<>>
+class _LIBCUDACXX_TYPE_VIS boyer_moore_horspool_searcher {
+private:
+    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type;
+    typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type      value_type;
+    typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate,
+                    _CUDA_VSTD::is_integral<value_type>::value && // what about enums?
+                    sizeof(value_type) == 1 &&
+                    is_same<_Hash, hash<value_type>>::value &&
+                    is_same<_BinaryPredicate, equal_to<>>::value
+            > skip_table_type;
+
+public:
+    boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, 
+                _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
+            : __first_(__f), __last_(__l), __pred_(__pred),
+              __pattern_length_(_CUDA_VSTD::distance(__first_, __last_)),
+              __skip_{_CUDA_VSTD::make_shared<skip_table_type>(__pattern_length_, __pattern_length_, __hf, __pred_)}
+        {
+    //  build the skip table
+            if ( __f != __l )
+            {
+                __l = __l - 1;
+                for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i )
+                    __skip_->insert(*__f, __pattern_length_ - 1 - __i);
+            }
+        }
+            
+    template <typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
+    {
+        static_assert ( std::is_same<
+                std::__remove_cvref_t<typename std::iterator_traits<_RandomAccessIterator1>::value_type>, 
+                std::__remove_cvref_t<typename std::iterator_traits<_RandomAccessIterator2>::value_type>
+                    >::value,
+                "Corpus and Pattern iterators must point to the same type" );
+
+        if (__f      == __l )    return make_pair(__l, __l); // empty corpus
+        if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
+
+    //  If the pattern is larger than the corpus, we can't find it!
+        if ( __pattern_length_ > _CUDA_VSTD::distance (__f, __l)) 
+            return make_pair(__l, __l);
+
+    //  Do the search 
+        return this->__search(__f, __l);
+    }
+        
+private:
+    _RandomAccessIterator1      __first_;
+    _RandomAccessIterator1      __last_;
+    _BinaryPredicate            __pred_;
+    difference_type             __pattern_length_;
+    shared_ptr<skip_table_type> __skip_;
+
+    template <typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    __search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const {
+        _RandomAccessIterator2 __cur = __f;
+        const _RandomAccessIterator2 __last = __l - __pattern_length_;
+        const skip_table_type & __skip = *__skip_.get();
+
+        while (__cur <= __last)
+        {
+        //  Do we match right where we are?
+            difference_type __j = __pattern_length_;
+            while (__pred_(__first_[__j-1], __cur[__j-1]))
+            {
+                __j--;
+            //  We matched - we're done!
+                if ( __j == 0 )
+                    return make_pair(__cur, __cur + __pattern_length_);
+            }
+            __cur += __skip[__cur[__pattern_length_-1]];
+        }
+        
+        return make_pair(__l, __l);
+    }
+};
+
+template<class _RandomAccessIterator, 
+         class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>, 
+         class _BinaryPredicate = equal_to<>>
+_LIBCUDACXX_INLINE_VISIBILITY
+boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
+make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, 
+                    _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
+{
+    return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
+}
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+_LIBCUDACXX_POP_MACROS
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_FUNCTIONAL */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator
new file mode 100644
index 0000000000000000000000000000000000000000..05fbb7859ff4cee694a5a0c3bf48010aab41e358
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/iterator
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//===----------------------------- iterator -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_ITERATOR
+#define _LIBCUDACXX_EXPERIMENTAL_ITERATOR
+
+/*
+namespace std {
+  namespace experimental {
+    inline namespace fundamentals_v2 {
+
+    template <class DelimT, class charT = char, class traits = char_traits<charT>>
+        class ostream_joiner {
+        public:
+         typedef charT                        char_type;
+         typedef traits                       traits_type;
+         typedef basic_ostream<charT, traits> ostream_type;
+         typedef output_iterator_tag          iterator_category;
+         typedef void                         value_type;
+         typedef void                         difference_type;
+         typedef void                         pointer;
+         typedef void                         reference;
+      
+         ostream_joiner(ostream_type& s, const DelimT& delimiter);
+         ostream_joiner(ostream_type& s, DelimT&& delimiter);
+
+         template<typename T>  
+         ostream_joiner& operator=(const T& value);
+
+         ostream_joiner& operator*() noexcept;
+         ostream_joiner& operator++() noexcept;
+         ostream_joiner& operator++(int) noexcept;
+   private:
+      ostream_type* out_stream;   // exposition only 
+      DelimT delim;               // exposition only 
+      bool first_element;         // exposition only
+   };
+
+  template <class charT, class traits, class DelimT>
+    ostream_joiner<decay_t<DelimT>, charT, traits>
+    make_ostream_joiner(basic_ostream<charT, traits>& os, DelimT&& delimiter);
+
+    } // inline namespace fundamentals_v2
+  } // namespace experimental
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#include <iterator>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
+class ostream_joiner {
+public:
+
+    typedef _CharT                               char_type;
+    typedef _Traits                              traits_type;
+    typedef basic_ostream<char_type,traits_type> ostream_type;
+    typedef output_iterator_tag                  iterator_category;
+    typedef void                                 value_type;
+    typedef void                                 difference_type;
+    typedef void                                 pointer;
+    typedef void                                 reference;
+
+    ostream_joiner(ostream_type& __os, _Delim&& __d)
+        : __output_iter(_CUDA_VSTD::addressof(__os)), __delim(_CUDA_VSTD::move(__d)), __first(true) {}
+        
+    ostream_joiner(ostream_type& __os, const _Delim& __d)
+        : __output_iter(_CUDA_VSTD::addressof(__os)), __delim(__d), __first(true) {}
+    
+
+    template<typename _Tp>
+    ostream_joiner& operator=(const _Tp& __v)
+    {
+        if (!__first)
+            *__output_iter << __delim;
+        __first = false;
+        *__output_iter << __v;
+        return *this;
+    }
+
+    ostream_joiner& operator*()     _NOEXCEPT { return *this; }
+    ostream_joiner& operator++()    _NOEXCEPT { return *this; }
+    ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
+
+private:
+    ostream_type*   __output_iter;
+    _Delim          __delim;
+    bool            __first;
+};
+
+
+template <class _CharT, class _Traits, class _Delim>
+ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>
+make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
+{ return ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>(__os, _CUDA_VSTD::forward<_Delim>(__d)); }
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+#endif /* _LIBCUDACXX_STD_VER > 11 */
+
+#endif // _LIBCUDACXX_EXPERIMENTAL_ITERATOR
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/list b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/list
new file mode 100644
index 0000000000000000000000000000000000000000..0600d27e65a29f164c3e71ad583db2d93fe5d7b7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/list
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===--------------------------- list ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_LIST
+#define _LIBCUDACXX_EXPERIMENTAL_LIST
+/*
+    experimental/list synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using list = std::list<T,polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <list>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using list = _CUDA_VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_LIST */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/map b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/map
new file mode 100644
index 0000000000000000000000000000000000000000..222836e18011bfd4043bfeaf40d69612c3cbee44
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/map
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+//===----------------------------- map ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_MAP
+#define _LIBCUDACXX_EXPERIMENTAL_MAP
+/*
+    experimental/map synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T, class Compare = less<Key>>
+  using map = std::map<Key, T, Compare,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T, class Compare = less<Key>>
+  using multimap = std::multimap<Key, T, Compare,
+                                 polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <map>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Key, class _Value, class  _Compare = less<_Key>>
+using map = _CUDA_VSTD::map<_Key, _Value, _Compare,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+template <class _Key, class _Value, class  _Compare = less<_Key>>
+using multimap = _CUDA_VSTD::multimap<_Key, _Value, _Compare,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_MAP */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource
new file mode 100644
index 0000000000000000000000000000000000000000..1564496c5457298ad1c8db8dc425571a668a804a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/memory_resource
@@ -0,0 +1,426 @@
+// -*- C++ -*-
+//===------------------------ memory_resource -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE
+#define _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE
+
+/**
+    experimental/memory_resource synopsis
+
+// C++1y
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  class memory_resource;
+
+  bool operator==(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+  bool operator!=(const memory_resource& a,
+                  const memory_resource& b) noexcept;
+
+  template <class Tp> class polymorphic_allocator;
+
+  template <class T1, class T2>
+  bool operator==(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+  template <class T1, class T2>
+  bool operator!=(const polymorphic_allocator<T1>& a,
+                  const polymorphic_allocator<T2>& b) noexcept;
+
+  // The name resource_adaptor_imp is for exposition only.
+  template <class Allocator> class resource_adaptor_imp;
+
+  template <class Allocator>
+    using resource_adaptor = resource_adaptor_imp<
+      allocator_traits<Allocator>::rebind_alloc<char>>;
+
+  // Global memory resources
+  memory_resource* new_delete_resource() noexcept;
+  memory_resource* null_memory_resource() noexcept;
+
+  // The default memory resource
+  memory_resource* set_default_resource(memory_resource* r) noexcept;
+  memory_resource* get_default_resource() noexcept;
+
+  // Standard memory resources
+  struct pool_options;
+  class synchronized_pool_resource;
+  class unsynchronized_pool_resource;
+  class monotonic_buffer_resource;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <experimental/__memory>
+#include <limits>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+#include <cstddef>
+#include <cstdlib>
+#include <__debug>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+// Round __s up to next multiple of __a.
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
+{
+    _LIBCUDACXX_ASSERT(__s + __a > __s, "aligned allocation size overflows");
+    return (__s + __a - 1) & ~(__a - 1);
+}
+
+// 8.5, memory.resource
+class _LIBCUDACXX_TYPE_VIS memory_resource
+{
+    static const size_t __max_align = _LIBCUDACXX_ALIGNOF(max_align_t);
+
+// 8.5.2, memory.resource.public
+public:
+    virtual ~memory_resource() = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void* allocate(size_t __bytes, size_t __align = __max_align)
+        { return do_allocate(__bytes, __align); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
+        { do_deallocate(__p, __bytes, __align); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool is_equal(memory_resource const & __other) const _NOEXCEPT
+        { return do_is_equal(__other); }
+
+// 8.5.3, memory.resource.priv
+protected:
+    virtual void* do_allocate(size_t, size_t) = 0;
+    virtual void do_deallocate(void*, size_t, size_t) = 0;
+    virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
+};
+
+// 8.5.4, memory.resource.eq
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator==(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return &__lhs == &__rhs || __lhs.is_equal(__rhs);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator!=(memory_resource const & __lhs,
+                memory_resource const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+_LIBCUDACXX_FUNC_VIS
+memory_resource * new_delete_resource() _NOEXCEPT;
+
+_LIBCUDACXX_FUNC_VIS
+memory_resource * null_memory_resource() _NOEXCEPT;
+
+_LIBCUDACXX_FUNC_VIS
+memory_resource * get_default_resource() _NOEXCEPT;
+
+_LIBCUDACXX_FUNC_VIS
+memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
+
+// 8.6, memory.polymorphic.allocator.class
+
+// 8.6.1, memory.polymorphic.allocator.overview
+template <class _ValueType>
+class _LIBCUDACXX_TEMPLATE_VIS polymorphic_allocator
+{
+public:
+    typedef _ValueType value_type;
+
+    // 8.6.2, memory.polymorphic.allocator.ctor
+    _LIBCUDACXX_INLINE_VISIBILITY
+    polymorphic_allocator() _NOEXCEPT
+      : __res_(_CUDA_VSTD_LFTS_PMR::get_default_resource())
+    {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    polymorphic_allocator(memory_resource * __r) _NOEXCEPT
+      : __res_(__r)
+    {}
+
+    polymorphic_allocator(polymorphic_allocator const &) = default;
+
+    template <class _Tp>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
+      : __res_(__other.resource())
+    {}
+
+    polymorphic_allocator &
+    operator=(polymorphic_allocator const &) = delete;
+
+    // 8.6.3, memory.polymorphic.allocator.mem
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _ValueType* allocate(size_t __n) {
+        if (__n > __max_size()) {
+            __throw_length_error(
+                "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
+                " 'n' exceeds maximum supported size");
+        }
+        return static_cast<_ValueType*>(
+            __res_->allocate(__n * sizeof(_ValueType), _LIBCUDACXX_ALIGNOF(_ValueType))
+        );
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
+        _LIBCUDACXX_ASSERT(__n <= __max_size(),
+                       "deallocate called for size which exceeds max_size()");
+        __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCUDACXX_ALIGNOF(_ValueType));
+    }
+
+    template <class _Tp, class ..._Ts>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(_Tp* __p, _Ts &&... __args)
+    {
+        _CUDA_VSTD_LFTS::__lfts_user_alloc_construct(
+            __p, *this, _CUDA_VSTD::forward<_Ts>(__args)...
+          );
+    }
+
+    template <class _T1, class _T2, class ..._Args1, class ..._Args2>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
+                   tuple<_Args1...> __x, tuple<_Args2...> __y)
+    {
+        ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
+          , __transform_tuple(
+              typename __lfts_uses_alloc_ctor<
+                  _T1, polymorphic_allocator&, _Args1...
+              >::type()
+            , _CUDA_VSTD::move(__x)
+            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
+          )
+          , __transform_tuple(
+              typename __lfts_uses_alloc_ctor<
+                  _T2, polymorphic_allocator&, _Args2...
+              >::type()
+            , _CUDA_VSTD::move(__y)
+            , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
+          )
+        );
+    }
+
+    template <class _T1, class _T2>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2>* __p) {
+        construct(__p, piecewise_construct, tuple<>(), tuple<>());
+    }
+
+    template <class _T1, class _T2, class _Up, class _Vp>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
+        construct(__p, piecewise_construct
+          , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Up>(__u))
+          , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Vp>(__v)));
+    }
+
+    template <class _T1, class _T2, class _U1, class _U2>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
+        construct(__p, piecewise_construct
+            , _CUDA_VSTD::forward_as_tuple(__pr.first)
+            , _CUDA_VSTD::forward_as_tuple(__pr.second));
+    }
+
+    template <class _T1, class _T2, class _U1, class _U2>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
+        construct(__p, piecewise_construct
+            , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_U1>(__pr.first))
+            , _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_U2>(__pr.second)));
+    }
+
+    template <class _Tp>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void destroy(_Tp * __p) _NOEXCEPT
+        { __p->~_Tp(); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    polymorphic_allocator
+    select_on_container_copy_construction() const _NOEXCEPT
+        { return polymorphic_allocator(); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    memory_resource * resource() const _NOEXCEPT
+        { return __res_; }
+
+private:
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    tuple<_Args&&...>
+    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
+                      __tuple_indices<_Idx...>) const
+    {
+        return _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
+    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>)
+    {
+        using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
+        return _Tup(allocator_arg, *this,
+                    _CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))...);
+    }
+
+    template <class ..._Args, size_t ..._Idx>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    tuple<_Args&&..., polymorphic_allocator&>
+    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
+                      __tuple_indices<_Idx...>)
+    {
+        using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
+        return _Tup(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__t))..., *this);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t __max_size() const _NOEXCEPT
+        { return numeric_limits<size_t>::max() / sizeof(value_type); }
+
+    memory_resource * __res_;
+};
+
+// 8.6.4, memory.polymorphic.allocator.eq
+
+template <class _Tp, class _Up>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator==(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return *__lhs.resource() == *__rhs.resource();
+}
+
+template <class _Tp, class _Up>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
+                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+
+// 8.7, memory.resource.adaptor
+
+// 8.7.1, memory.resource.adaptor.overview
+template <class _CharAlloc>
+class _LIBCUDACXX_TEMPLATE_VIS __resource_adaptor_imp
+  : public memory_resource
+{
+    using _CTraits = allocator_traits<_CharAlloc>;
+    static_assert(is_same<typename _CTraits::value_type, char>::value
+               && is_same<typename _CTraits::pointer, char*>::value
+               && is_same<typename _CTraits::void_pointer, void*>::value, "");
+
+    static const size_t _MaxAlign = _LIBCUDACXX_ALIGNOF(max_align_t);
+
+    using _Alloc = typename _CTraits::template rebind_alloc<
+            typename aligned_storage<_MaxAlign, _MaxAlign>::type
+        >;
+
+    using _ValueType = typename _Alloc::value_type;
+
+    _Alloc __alloc_;
+
+public:
+    typedef _CharAlloc allocator_type;
+
+    __resource_adaptor_imp() = default;
+    __resource_adaptor_imp(__resource_adaptor_imp const &) = default;
+    __resource_adaptor_imp(__resource_adaptor_imp &&) = default;
+
+    // 8.7.2, memory.resource.adaptor.ctor
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __resource_adaptor_imp(allocator_type const & __a)
+      : __alloc_(__a)
+    {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __resource_adaptor_imp(allocator_type && __a)
+      : __alloc_(_CUDA_VSTD::move(__a))
+    {}
+
+    __resource_adaptor_imp &
+    operator=(__resource_adaptor_imp const &) = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+    { return __alloc_; }
+
+// 8.7.3, memory.resource.adaptor.mem
+protected:
+    virtual void * do_allocate(size_t __bytes, size_t)
+    {
+        if (__bytes > __max_size()) {
+            __throw_length_error(
+                "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
+                " 'bytes' exceeds maximum supported size");
+        }
+        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
+        return __alloc_.allocate(__s);
+    }
+
+    virtual void do_deallocate(void * __p, size_t __bytes, size_t)
+    {
+        _LIBCUDACXX_ASSERT(__bytes <= __max_size(),
+            "do_deallocate called for size which exceeds the maximum allocation size");
+        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
+        __alloc_.deallocate((_ValueType*)__p, __s);
+    }
+
+    virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
+        __resource_adaptor_imp const * __p
+          = dynamic_cast<__resource_adaptor_imp const *>(&__other);
+        return __p  ? __alloc_ == __p->__alloc_ : false;
+    }
+
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t __max_size() const _NOEXCEPT {
+        return numeric_limits<size_t>::max() - _MaxAlign;
+    }
+};
+
+template <class _Alloc>
+using resource_adaptor = __resource_adaptor_imp<
+    typename allocator_traits<_Alloc>::template rebind_alloc<char>
+  >;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+_LIBCUDACXX_POP_MACROS
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_MEMORY_RESOURCE */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/propagate_const b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/propagate_const
new file mode 100644
index 0000000000000000000000000000000000000000..feea80013494c6e5cdab20ca06fab11975076bd0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/propagate_const
@@ -0,0 +1,578 @@
+// -*- C++ -*-
+//===------------------------ propagate_const -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_PROPAGATE_CONST
+#define _LIBCUDACXX_EXPERIMENTAL_PROPAGATE_CONST
+/*
+    propagate_const synopsis
+
+    namespace std { namespace experimental { inline namespace fundamentals_v2 {
+
+    // [propagate_const]
+    template <class T> class propagate_const;
+
+    // [propagate_const.underlying], underlying pointer access
+    constexpr const _Tp& _CUDA_VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
+    constexpr T& _CUDA_VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
+
+    // [propagate_const.relational], relational operators
+    template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
+    template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
+
+    // [propagate_const.algorithms], specialized algorithms
+    template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
+
+    template <class T>
+    class propagate_const
+    {
+
+    public:
+      typedef remove_reference_t<decltype(*declval<T&>())> element_type;
+
+      // [propagate_const.ctor], constructors
+      constexpr propagate_const() = default;
+      propagate_const(const propagate_const& p) = delete;
+      constexpr propagate_const(propagate_const&& p) = default;
+      template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
+      template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
+
+      // [propagate_const.assignment], assignment
+      propagate_const& operator=(const propagate_const& p) = delete;
+      constexpr propagate_const& operator=(propagate_const&& p) = default;
+      template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+      template <class U> constexpr propagate_const& operator=(U&& u); // see below
+
+      // [propagate_const.const_observers], const observers
+      explicit constexpr operator bool() const;
+      constexpr const element_type* operator->() const;
+      constexpr operator const element_type*() const; // Not always defined
+      constexpr const element_type& operator*() const;
+      constexpr const element_type* get() const;
+
+      // [propagate_const.non_const_observers], non-const observers
+      constexpr element_type* operator->();
+      constexpr operator element_type*(); // Not always defined
+      constexpr element_type& operator*();
+      constexpr element_type* get();
+
+      // [propagate_const.modifiers], modifiers
+      constexpr void swap(propagate_const& pt) noexcept(see below)
+
+    private:
+      T t_; // exposition only
+    };
+
+  } // namespace fundamentals_v2
+  } // namespace experimental
+
+  // [propagate_const.hash], hash support
+  template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+  // [propagate_const.comparison_function_objects], comparison function objects
+  template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_V2
+
+
+template <class _Tp>
+class propagate_const;
+
+template <class _Up>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+
+template <class _Up>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+template <class _Tp>
+class propagate_const
+{
+public:
+  typedef remove_reference_t<decltype(*_CUDA_VSTD::declval<_Tp&>())> element_type;
+
+  static_assert(!is_array<_Tp>::value,
+      "Instantiation of propagate_const with an array type is ill-formed.");
+  static_assert(!is_reference<_Tp>::value,
+      "Instantiation of propagate_const with a reference type is ill-formed.");
+  static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
+      "Instantiation of propagate_const with a function-pointer type is ill-formed.");
+  static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
+      "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
+
+private:
+  template <class _Up>
+  static _LIBCUDACXX_CONSTEXPR element_type* __get_pointer(_Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static _LIBCUDACXX_CONSTEXPR element_type* __get_pointer(_Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+
+  template <class _Up>
+  static _LIBCUDACXX_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static _LIBCUDACXX_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+
+  template <class _Up>
+  struct __is_propagate_const : false_type
+  {
+  };
+
+  template <class _Up>
+  struct __is_propagate_const<propagate_const<_Up>> : true_type
+  {
+  };
+
+  _Tp __t_;
+
+public:
+
+  template <class _Up> friend _LIBCUDACXX_CONSTEXPR const _Up& ::_CUDA_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+  template <class _Up> friend _LIBCUDACXX_CONSTEXPR _Up& ::_CUDA_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+  _LIBCUDACXX_CONSTEXPR propagate_const() = default;
+
+  propagate_const(const propagate_const&) = delete;
+
+  _LIBCUDACXX_CONSTEXPR propagate_const(propagate_const&&) = default;
+
+  template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = true>
+  explicit _LIBCUDACXX_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(_CUDA_VSTD_LFTS_V2::get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = false>
+  _LIBCUDACXX_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(_CUDA_VSTD_LFTS_V2::get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = true>
+  explicit _LIBCUDACXX_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = false>
+  _LIBCUDACXX_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+
+  propagate_const& operator=(const propagate_const&) = delete;
+
+  _LIBCUDACXX_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
+
+  template <class _Up>
+  _LIBCUDACXX_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
+  {
+    __t_ = std::move(_CUDA_VSTD_LFTS_V2::get_underlying(__pu));
+    return *this;
+  }
+
+  template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
+  _LIBCUDACXX_CONSTEXPR propagate_const& operator=(_Up&& __u)
+  {
+    __t_ = std::forward<_Up>(__u);
+    return *this;
+  }
+
+  _LIBCUDACXX_CONSTEXPR const element_type* get() const
+  {
+    return __get_pointer(__t_);
+  }
+
+  _LIBCUDACXX_CONSTEXPR element_type* get()
+  {
+    return __get_pointer(__t_);
+  }
+
+  explicit _LIBCUDACXX_CONSTEXPR operator bool() const
+  {
+    return get() != nullptr;
+  }
+
+  _LIBCUDACXX_CONSTEXPR const element_type* operator->() const
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
+                                  const _Tp_, const element_type *>::value>>
+  _LIBCUDACXX_CONSTEXPR operator const element_type *() const {
+    return get();
+  }
+
+  _LIBCUDACXX_CONSTEXPR const element_type& operator*() const
+  {
+    return *get();
+  }
+
+  _LIBCUDACXX_CONSTEXPR element_type* operator->()
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<
+                                  is_convertible<_Tp_, element_type *>::value>>
+  _LIBCUDACXX_CONSTEXPR operator element_type *() {
+    return get();
+  }
+
+  _LIBCUDACXX_CONSTEXPR element_type& operator*()
+  {
+    return *get();
+  }
+
+  _LIBCUDACXX_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+  {
+    using _CUDA_VSTD::swap;
+    swap(__t_, __pt.__t_);
+  }
+};
+
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr == _CUDA_VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr != _CUDA_VSTD_LFTS_V2::get_underlying(__pt);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) == _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) != _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) < _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) > _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) <= _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) >= _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) == __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) != __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) < __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) > __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) <= __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return _CUDA_VSTD_LFTS_V2::get_underlying(__pt) >= __u;
+}
+
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t == _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t != _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t < _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t > _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t <= _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t >= _CUDA_VSTD_LFTS_V2::get_underlying(__pu);
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+{
+  __pc1.swap(__pc2);
+}
+
+template <class _Tp>
+_LIBCUDACXX_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+  return __pt.__t_;
+}
+
+template <class _Tp>
+_LIBCUDACXX_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
+{
+  return __pt.__t_;
+}
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_V2
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef size_t result_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+
+  size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
+  {
+    return std::hash<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1));
+  }
+};
+
+template <class _Tp>
+struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::equal_to<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::not_equal_to<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less_equal<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater_equal<_Tp>()(_CUDA_VSTD_LFTS_V2::get_underlying(__pc1), _CUDA_VSTD_LFTS_V2::get_underlying(__pc2));
+  }
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_STD_VER > 11
+#endif // _LIBCUDACXX_EXPERIMENTAL_PROPAGATE_CONST
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/regex b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/regex
new file mode 100644
index 0000000000000000000000000000000000000000..3a7cd32ccecb27054498c4b23734bfc62d60113a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/regex
@@ -0,0 +1,61 @@
+// -*- C++ -*-
+//===----------------------------- regex ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_REGEX
+#define _LIBCUDACXX_EXPERIMENTAL_REGEX
+/*
+    experimental/regex synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class BidirectionalIterator>
+  using match_results =
+    std::match_results<BidirectionalIterator,
+                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
+
+  typedef match_results<const char*> cmatch;
+  typedef match_results<const wchar_t*> wcmatch;
+  typedef match_results<string::const_iterator> smatch;
+  typedef match_results<wstring::const_iterator> wsmatch;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <regex>
+#include <experimental/string>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _BiDirIter>
+using match_results =
+    _CUDA_VSTD::match_results<_BiDirIter,
+        polymorphic_allocator<_CUDA_VSTD::sub_match<_BiDirIter>>>;
+
+typedef match_results<const char*> cmatch;
+typedef match_results<const wchar_t*> wcmatch;
+typedef match_results<_CUDA_VSTD_LFTS_PMR::string::const_iterator> smatch;
+typedef match_results<_CUDA_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_REGEX */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/set b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/set
new file mode 100644
index 0000000000000000000000000000000000000000..995d50a3d489d6fcd286a6958c724451e4dd5e91
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/set
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+//===--------------------------- list ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_SET
+#define _LIBCUDACXX_EXPERIMENTAL_SET
+/*
+    experimental/set synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T, class Compare = less<Key>>
+  using set = std::set<Key, T, Compare,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T, class Compare = less<Key>>
+  using multiset = std::multiset<Key, T, Compare,
+                                 polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <set>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Value, class  _Compare = less<_Value>>
+using set = _CUDA_VSTD::set<_Value, _Compare,
+                        polymorphic_allocator<_Value>>;
+
+template <class _Value, class  _Compare = less<_Value>>
+using multiset = _CUDA_VSTD::multiset<_Value, _Compare,
+                        polymorphic_allocator<_Value>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_SET */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/simd b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/simd
new file mode 100644
index 0000000000000000000000000000000000000000..99453767b5fe80fd53a4b5dd61c5729fdf2169f3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/simd
@@ -0,0 +1,1569 @@
+// -*- C++ -*-
+//===------------------------------- simd ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCUDACXX_EXPERIMENTAL_SIMD
+#define _LIBCUDACXX_EXPERIMENTAL_SIMD
+
+/*
+    experimental/simd synopsis
+
+namespace std::experimental {
+
+inline namespace parallelism_v2 {
+
+namespace simd_abi {
+
+struct scalar {};
+template <int N> struct fixed_size {};
+template <typename T> inline constexpr int max_fixed_size = implementation-defined;
+template <typename T> using compatible = implementation-defined;
+template <typename T> using native = implementation-defined;
+
+} // simd_abi
+
+struct element_aligned_tag {};
+struct vector_aligned_tag {};
+template <size_t> struct overaligned_tag {};
+inline constexpr element_aligned_tag element_aligned{};
+inline constexpr vector_aligned_tag vector_aligned{};
+template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
+
+// traits [simd.traits]
+template <class T> struct is_abi_tag;
+template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
+
+template <class T> struct is_simd;
+template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
+
+template <class T> struct is_simd_mask;
+template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
+
+template <class T> struct is_simd_flag_type;
+template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
+
+template <class T, size_t N> struct abi_for_size { using type = see below; };
+template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type;
+
+template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;
+template <class T, class Abi = simd_abi::compatible<T>>
+inline constexpr size_t simd_size_v = simd_size<T, Abi>::value;
+
+template <class T, class U = typename T::value_type> struct memory_alignment;
+template <class T, class U = typename T::value_type>
+inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
+
+// class template simd [simd.class]
+template <class T, class Abi = simd_abi::compatible<T>> class simd;
+template <class T> using native_simd = simd<T, simd_abi::native<T>>;
+template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
+
+// class template simd_mask [simd.mask.class]
+template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
+template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
+template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
+
+// casts [simd.casts]
+template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);
+template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);
+
+template <class T, class Abi>
+fixed_size_simd<T, simd_size_v<T, Abi>> to_fixed_size(const simd<T, Abi>&) noexcept;
+template <class T, class Abi>
+fixed_size_simd_mask<T, simd_size_v<T, Abi>> to_fixed_size(const simd_mask<T, Abi>&) noexcept;
+template <class T, size_t N> native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
+template <class T, size_t N>
+native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>> &) noexcept;
+template <class T, size_t N> simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;
+template <class T, size_t N> simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
+
+template <size_t... Sizes, class T, class Abi>
+tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);
+template <size_t... Sizes, class T, class Abi>
+tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T, Abi>&);
+template <class V, class Abi>
+array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
+const simd<typename V::value_type, Abi>&);
+template <class V, class Abi>
+array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
+const simd_mask<typename V::value_type, Abi>&);
+
+template <class T, class... Abis>
+simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd<T, Abis>&...);
+template <class T, class... Abis>
+simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd_mask<T, Abis>&...);
+
+// reductions [simd.mask.reductions]
+template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
+template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
+template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
+template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
+template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
+template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
+template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
+
+bool all_of(see below) noexcept;
+bool any_of(see below) noexcept;
+bool none_of(see below) noexcept;
+bool some_of(see below) noexcept;
+int popcount(see below) noexcept;
+int find_first_set(see below) noexcept;
+int find_last_set(see below) noexcept;
+
+// masked assignment [simd.whereexpr]
+template <class M, class T> class const_where_expression;
+template <class M, class T> class where_expression;
+
+// masked assignment [simd.mask.where]
+template <class T> struct nodeduce { using type = T; }; // exposition only
+
+template <class T> using nodeduce_t = typename nodeduce<T>::type; // exposition only
+
+template <class T, class Abi>
+where_expression<simd_mask<T, Abi>, simd<T, Abi>>
+where(const typename simd<T, Abi>::mask_type&, simd<T, Abi>&) noexcept;
+
+template <class T, class Abi>
+const_where_expression<simd_mask<T, Abi>, const simd<T, Abi>>
+where(const typename simd<T, Abi>::mask_type&, const simd<T, Abi>&) noexcept;
+
+template <class T, class Abi>
+where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>
+where(const nodeduce_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;
+
+template <class T, class Abi>
+const_where_expression<simd_mask<T, Abi>, const simd_mask<T, Abi>>
+where(const nodeduce_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;
+
+template <class T> where_expression<bool, T> where(see below k, T& d) noexcept;
+
+template <class T>
+const_where_expression<bool, const T> where(see below k, const T& d) noexcept;
+
+// reductions [simd.reductions]
+template <class T, class Abi, class BinaryOperation = std::plus<>>
+T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());
+
+template <class M, class V, class BinaryOperation>
+typename V::value_type reduce(const const_where_expression<M, V>& x,
+typename V::value_type neutral_element, BinaryOperation binary_op);
+
+template <class M, class V>
+typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());
+
+template <class M, class V>
+typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);
+
+template <class M, class V>
+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);
+
+template <class M, class V>
+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);
+
+template <class M, class V>
+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);
+
+template <class T, class Abi> T hmin(const simd<T, Abi>&);
+template <class M, class V> T hmin(const const_where_expression<M, V>&);
+template <class T, class Abi> T hmax(const simd<T, Abi>&);
+template <class M, class V> T hmax(const const_where_expression<M, V>&);
+
+// algorithms [simd.alg]
+template <class T, class Abi> simd<T, Abi> min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+template <class T, class Abi> simd<T, Abi> max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+template <class T, class Abi>
+std::pair<simd<T, Abi>, simd<T, Abi>> minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+template <class T, class Abi>
+simd<T, Abi> clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);
+
+// [simd.whereexpr]
+template <class M, class T>
+class const_where_expression {
+  const M& mask; // exposition only
+  T& data; // exposition only
+public:
+  const_where_expression(const const_where_expression&) = delete;
+  const_where_expression& operator=(const const_where_expression&) = delete;
+  remove_const_t<T> operator-() const &&;
+  template <class U, class Flags> void copy_to(U* mem, Flags f) const &&;
+};
+
+template <class M, class T>
+class where_expression : public const_where_expression<M, T> {
+public:
+  where_expression(const where_expression&) = delete;
+  where_expression& operator=(const where_expression&) = delete;
+  template <class U> void operator=(U&& x);
+  template <class U> void operator+=(U&& x);
+  template <class U> void operator-=(U&& x);
+  template <class U> void operator*=(U&& x);
+  template <class U> void operator/=(U&& x);
+  template <class U> void operator%=(U&& x);
+  template <class U> void operator&=(U&& x);
+  template <class U> void operator|=(U&& x);
+  template <class U> void operator^=(U&& x);
+  template <class U> void operator<<=(U&& x);
+  template <class U> void operator>>=(U&& x);
+  void operator++();
+  void operator++(int);
+  void operator--();
+  void operator--(int);
+  template <class U, class Flags> void copy_from(const U* mem, Flags);
+};
+
+// [simd.class]
+template <class T, class Abi> class simd {
+public:
+  using value_type = T;
+  using reference = see below;
+  using mask_type = simd_mask<T, Abi>;
+
+  using abi_type = Abi;
+  static constexpr size_t size() noexcept;
+  simd() = default;
+
+  // implicit type conversion constructor
+  template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);
+
+  // implicit broadcast constructor (see below for constraints)
+  template <class U> simd(U&& value);
+
+  // generator constructor (see below for constraints)
+  template <class G> explicit simd(G&& gen);
+
+  // load constructor
+  template <class U, class Flags> simd(const U* mem, Flags f);
+
+  // loads [simd.load]
+  template <class U, class Flags> void copy_from(const U* mem, Flags f);
+
+  // stores [simd.store]
+  template <class U, class Flags> void copy_to(U* mem, Flags f) const;
+
+  // scalar access [simd.subscr]
+  reference operator[](size_t);
+  value_type operator[](size_t) const;
+
+  // unary operators [simd.unary]
+  simd& operator++();
+  simd operator++(int);
+  simd& operator--();
+  simd operator--(int);
+  mask_type operator!() const;
+  simd operator~() const; // see below
+  simd operator+() const;
+  simd operator-() const;
+
+  // binary operators [simd.binary]
+  friend simd operator+ (const simd&, const simd&);
+  friend simd operator- (const simd&, const simd&);
+  friend simd operator* (const simd&, const simd&);
+  friend simd operator/ (const simd&, const simd&);
+  friend simd operator% (const simd&, const simd&);
+  friend simd operator& (const simd&, const simd&);
+  friend simd operator| (const simd&, const simd&);
+  friend simd operator^ (const simd&, const simd&);
+  friend simd operator<<(const simd&, const simd&);
+  friend simd operator>>(const simd&, const simd&);
+  friend simd operator<<(const simd&, int);
+  friend simd operator>>(const simd&, int);
+
+  // compound assignment [simd.cassign]
+  friend simd& operator+= (simd&, const simd&);
+  friend simd& operator-= (simd&, const simd&);
+  friend simd& operator*= (simd&, const simd&);
+  friend simd& operator/= (simd&, const simd&);
+  friend simd& operator%= (simd&, const simd&);
+
+  friend simd& operator&= (simd&, const simd&);
+  friend simd& operator|= (simd&, const simd&);
+  friend simd& operator^= (simd&, const simd&);
+  friend simd& operator<<=(simd&, const simd&);
+  friend simd& operator>>=(simd&, const simd&);
+  friend simd& operator<<=(simd&, int);
+  friend simd& operator>>=(simd&, int);
+
+  // compares [simd.comparison]
+  friend mask_type operator==(const simd&, const simd&);
+  friend mask_type operator!=(const simd&, const simd&);
+  friend mask_type operator>=(const simd&, const simd&);
+  friend mask_type operator<=(const simd&, const simd&);
+  friend mask_type operator> (const simd&, const simd&);
+  friend mask_type operator< (const simd&, const simd&);
+};
+
+// [simd.math]
+template <class Abi> using scharv = simd<signed char, Abi>; // exposition only
+template <class Abi> using shortv = simd<short, Abi>; // exposition only
+template <class Abi> using intv = simd<int, Abi>; // exposition only
+template <class Abi> using longv = simd<long int, Abi>; // exposition only
+template <class Abi> using llongv = simd<long long int, Abi>; // exposition only
+template <class Abi> using floatv = simd<float, Abi>; // exposition only
+template <class Abi> using doublev = simd<double, Abi>; // exposition only
+template <class Abi> using ldoublev = simd<long double, Abi>; // exposition only
+template <class T, class V> using samesize = fixed_size_simd<T, V::size()>; // exposition only
+
+template <class Abi> floatv<Abi> acos(floatv<Abi> x);
+template <class Abi> doublev<Abi> acos(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> acos(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> asin(floatv<Abi> x);
+template <class Abi> doublev<Abi> asin(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> asin(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> atan(floatv<Abi> x);
+template <class Abi> doublev<Abi> atan(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> atan(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> atan2(floatv<Abi> y, floatv<Abi> x);
+template <class Abi> doublev<Abi> atan2(doublev<Abi> y, doublev<Abi> x);
+template <class Abi> ldoublev<Abi> atan2(ldoublev<Abi> y, ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> cos(floatv<Abi> x);
+template <class Abi> doublev<Abi> cos(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> cos(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> sin(floatv<Abi> x);
+template <class Abi> doublev<Abi> sin(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> sin(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> tan(floatv<Abi> x);
+template <class Abi> doublev<Abi> tan(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> tan(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> acosh(floatv<Abi> x);
+template <class Abi> doublev<Abi> acosh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> acosh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> asinh(floatv<Abi> x);
+template <class Abi> doublev<Abi> asinh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> asinh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> atanh(floatv<Abi> x);
+template <class Abi> doublev<Abi> atanh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> atanh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> cosh(floatv<Abi> x);
+template <class Abi> doublev<Abi> cosh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> cosh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> sinh(floatv<Abi> x);
+template <class Abi> doublev<Abi> sinh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> sinh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> tanh(floatv<Abi> x);
+template <class Abi> doublev<Abi> tanh(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> tanh(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> exp(floatv<Abi> x);
+template <class Abi> doublev<Abi> exp(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> exp(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> exp2(floatv<Abi> x);
+template <class Abi> doublev<Abi> exp2(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> exp2(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> expm1(floatv<Abi> x);
+template <class Abi> doublev<Abi> expm1(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> expm1(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> frexp(floatv<Abi> value, samesize<int, floatv<Abi>>* exp);
+template <class Abi> doublev<Abi> frexp(doublev<Abi> value, samesize<int, doublev<Abi>>* exp);
+template <class Abi> ldoublev<Abi> frexp(ldoublev<Abi> value, samesize<int, ldoublev<Abi>>* exp);
+
+template <class Abi> samesize<int, floatv<Abi>> ilogb(floatv<Abi> x);
+template <class Abi> samesize<int, doublev<Abi>> ilogb(doublev<Abi> x);
+template <class Abi> samesize<int, ldoublev<Abi>> ilogb(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> ldexp(floatv<Abi> x, samesize<int, floatv<Abi>> exp);
+template <class Abi> doublev<Abi> ldexp(doublev<Abi> x, samesize<int, doublev<Abi>> exp);
+template <class Abi> ldoublev<Abi> ldexp(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> exp);
+
+template <class Abi> floatv<Abi> log(floatv<Abi> x);
+template <class Abi> doublev<Abi> log(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> log(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> log10(floatv<Abi> x);
+template <class Abi> doublev<Abi> log10(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> log10(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> log1p(floatv<Abi> x);
+template <class Abi> doublev<Abi> log1p(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> log1p(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> log2(floatv<Abi> x);
+template <class Abi> doublev<Abi> log2(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> log2(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> logb(floatv<Abi> x);
+template <class Abi> doublev<Abi> logb(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> logb(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> modf(floatv<Abi> value, floatv<Abi>* iptr);
+template <class Abi> doublev<Abi> modf(doublev<Abi> value, doublev<Abi>* iptr);
+template <class Abi> ldoublev<Abi> modf(ldoublev<Abi> value, ldoublev<Abi>* iptr);
+
+template <class Abi> floatv<Abi> scalbn(floatv<Abi> x, samesize<int, floatv<Abi>> n);
+template <class Abi> doublev<Abi> scalbn(doublev<Abi> x, samesize<int, doublev<Abi>> n);
+template <class Abi> ldoublev<Abi> scalbn(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> n);
+template <class Abi> floatv<Abi> scalbln(floatv<Abi> x, samesize<long int, floatv<Abi>> n);
+template <class Abi> doublev<Abi> scalbln(doublev<Abi> x, samesize<long int, doublev<Abi>> n);
+template <class Abi> ldoublev<Abi> scalbln(ldoublev<Abi> x, samesize<long int, ldoublev<Abi>> n);
+
+template <class Abi> floatv<Abi> cbrt(floatv<Abi> x);
+template <class Abi> doublev<Abi> cbrt(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> cbrt(ldoublev<Abi> x);
+
+template <class Abi> scharv<Abi> abs(scharv<Abi> j);
+template <class Abi> shortv<Abi> abs(shortv<Abi> j);
+template <class Abi> intv<Abi> abs(intv<Abi> j);
+template <class Abi> longv<Abi> abs(longv<Abi> j);
+template <class Abi> llongv<Abi> abs(llongv<Abi> j);
+template <class Abi> floatv<Abi> abs(floatv<Abi> j);
+template <class Abi> doublev<Abi> abs(doublev<Abi> j);
+template <class Abi> ldoublev<Abi> abs(ldoublev<Abi> j);
+
+template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
+template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
+template <class Abi> ldoublev<Abi> hypot(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
+
+template <class Abi> floatv<Abi> pow(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> pow(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> pow(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> sqrt(floatv<Abi> x);
+template <class Abi> doublev<Abi> sqrt(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> sqrt(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> erf(floatv<Abi> x);
+template <class Abi> doublev<Abi> erf(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> erf(ldoublev<Abi> x);
+template <class Abi> floatv<Abi> erfc(floatv<Abi> x);
+template <class Abi> doublev<Abi> erfc(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> erfc(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> lgamma(floatv<Abi> x);
+template <class Abi> doublev<Abi> lgamma(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> lgamma(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> tgamma(floatv<Abi> x);
+template <class Abi> doublev<Abi> tgamma(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> tgamma(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> ceil(floatv<Abi> x);
+template <class Abi> doublev<Abi> ceil(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> ceil(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> floor(floatv<Abi> x);
+template <class Abi> doublev<Abi> floor(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> floor(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> nearbyint(floatv<Abi> x);
+template <class Abi> doublev<Abi> nearbyint(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> nearbyint(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> rint(floatv<Abi> x);
+template <class Abi> doublev<Abi> rint(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> rint(ldoublev<Abi> x);
+
+template <class Abi> samesize<long int, floatv<Abi>> lrint(floatv<Abi> x);
+template <class Abi> samesize<long int, doublev<Abi>> lrint(doublev<Abi> x);
+template <class Abi> samesize<long int, ldoublev<Abi>> lrint(ldoublev<Abi> x);
+template <class Abi> samesize<long long int, floatv<Abi>> llrint(floatv<Abi> x);
+template <class Abi> samesize<long long int, doublev<Abi>> llrint(doublev<Abi> x);
+template <class Abi> samesize<long long int, ldoublev<Abi>> llrint(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> round(floatv<Abi> x);
+template <class Abi> doublev<Abi> round(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> round(ldoublev<Abi> x);
+template <class Abi> samesize<long int, floatv<Abi>> lround(floatv<Abi> x);
+template <class Abi> samesize<long int, doublev<Abi>> lround(doublev<Abi> x);
+template <class Abi> samesize<long int, ldoublev<Abi>> lround(ldoublev<Abi> x);
+template <class Abi> samesize<long long int, floatv<Abi>> llround(floatv<Abi> x);
+template <class Abi> samesize<long long int, doublev<Abi>> llround(doublev<Abi> x);
+template <class Abi> samesize<long long int, ldoublev<Abi>> llround(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> trunc(floatv<Abi> x);
+template <class Abi> doublev<Abi> trunc(doublev<Abi> x);
+template <class Abi> ldoublev<Abi> trunc(ldoublev<Abi> x);
+
+template <class Abi> floatv<Abi> fmod(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> fmod(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> fmod(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> remainder(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> remainder(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> remainder(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> remquo(floatv<Abi> x, floatv<Abi> y, samesize<int, floatv<Abi>>* quo);
+template <class Abi> doublev<Abi> remquo(doublev<Abi> x, doublev<Abi> y, samesize<int, doublev<Abi>>* quo);
+template <class Abi> ldoublev<Abi> remquo(ldoublev<Abi> x, ldoublev<Abi> y, samesize<int, ldoublev<Abi>>* quo);
+
+template <class Abi> floatv<Abi> copysign(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> copysign(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> copysign(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> doublev<Abi> nan(const char* tagp);
+template <class Abi> floatv<Abi> nanf(const char* tagp);
+template <class Abi> ldoublev<Abi> nanl(const char* tagp);
+
+template <class Abi> floatv<Abi> nextafter(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> nextafter(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> nextafter(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> nexttoward(floatv<Abi> x, ldoublev<Abi> y);
+template <class Abi> doublev<Abi> nexttoward(doublev<Abi> x, ldoublev<Abi> y);
+template <class Abi> ldoublev<Abi> nexttoward(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> fdim(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> fdim(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> fdim(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> fmax(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> fmax(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> fmax(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> fmin(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> doublev<Abi> fmin(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> ldoublev<Abi> fmin(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> floatv<Abi> fma(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
+template <class Abi> doublev<Abi> fma(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
+template <class Abi> ldoublev<Abi> fma(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
+
+template <class Abi> samesize<int, floatv<Abi>> fpclassify(floatv<Abi> x);
+template <class Abi> samesize<int, doublev<Abi>> fpclassify(doublev<Abi> x);
+template <class Abi> samesize<int, ldoublev<Abi>> fpclassify(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> isfinite(floatv<Abi> x);
+template <class Abi> simd_mask<double, Abi> isfinite(doublev<Abi> x);
+template <class Abi> simd_mask<long double, Abi> isfinite(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> isinf(floatv<Abi> x);
+template <class Abi> simd_mask<double, Abi> isinf(doublev<Abi> x);
+template <class Abi> simd_mask<long double, Abi> isinf(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> isnan(floatv<Abi> x);
+template <class Abi> simd_mask<double, Abi> isnan(doublev<Abi> x);
+template <class Abi> simd_mask<long double, Abi> isnan(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> isnormal(floatv<Abi> x);
+template <class Abi> simd_mask<double, Abi> isnormal(doublev<Abi> x);
+template <class Abi> simd_mask<long double, Abi> isnormal(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> signbit(floatv<Abi> x);
+template <class Abi> simd_mask<double, Abi> signbit(doublev<Abi> x);
+template <class Abi> simd_mask<long double, Abi> signbit(ldoublev<Abi> x);
+
+template <class Abi> simd_mask<float, Abi> isgreater(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> isgreater(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> isgreater(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> simd_mask<float, Abi> isgreaterequal(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> isgreaterequal(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> isgreaterequal(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> simd_mask<float, Abi> isless(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> isless(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> isless(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> simd_mask<float, Abi> islessequal(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> islessequal(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> islessequal(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> simd_mask<float, Abi> islessgreater(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> islessgreater(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> islessgreater(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class Abi> simd_mask<float, Abi> isunordered(floatv<Abi> x, floatv<Abi> y);
+template <class Abi> simd_mask<double, Abi> isunordered(doublev<Abi> x, doublev<Abi> y);
+template <class Abi> simd_mask<long double, Abi> isunordered(ldoublev<Abi> x, ldoublev<Abi> y);
+
+template <class V> struct simd_div_t { V quot, rem; };
+template <class Abi> simd_div_t<scharv<Abi>> div(scharv<Abi> numer, scharv<Abi> denom);
+template <class Abi> simd_div_t<shortv<Abi>> div(shortv<Abi> numer, shortv<Abi> denom);
+template <class Abi> simd_div_t<intv<Abi>> div(intv<Abi> numer, intv<Abi> denom);
+template <class Abi> simd_div_t<longv<Abi>> div(longv<Abi> numer, longv<Abi> denom);
+template <class Abi> simd_div_t<llongv<Abi>> div(llongv<Abi> numer, llongv<Abi> denom);
+
+// [simd.mask.class]
+template <class T, class Abi>
+class simd_mask {
+public:
+  using value_type = bool;
+  using reference = see below;
+  using simd_type = simd<T, Abi>;
+  using abi_type = Abi;
+  static constexpr size_t size() noexcept;
+  simd_mask() = default;
+
+  // broadcast constructor
+  explicit simd_mask(value_type) noexcept;
+
+  // implicit type conversion constructor
+  template <class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;
+
+  // load constructor
+  template <class Flags> simd_mask(const value_type* mem, Flags);
+
+  // loads [simd.mask.copy]
+  template <class Flags> void copy_from(const value_type* mem, Flags);
+  template <class Flags> void copy_to(value_type* mem, Flags) const;
+
+  // scalar access [simd.mask.subscr]
+  reference operator[](size_t);
+  value_type operator[](size_t) const;
+
+  // unary operators [simd.mask.unary]
+  simd_mask operator!() const noexcept;
+
+  // simd_mask binary operators [simd.mask.binary]
+  friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator| (const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept;
+
+  // simd_mask compound assignment [simd.mask.cassign]
+  friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
+
+  // simd_mask compares [simd.mask.comparison]
+  friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
+};
+
+} // parallelism_v2
+} // std::experimental
+
+*/
+
+#include <experimental/__config>
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <functional>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+#if _LIBCUDACXX_STD_VER >= 17
+
+enum class _StorageKind {
+  _Scalar,
+  _Array,
+  _VecExt,
+};
+
+template <_StorageKind __kind, int _Np>
+struct __simd_abi {};
+
+template <class _Tp, class _Abi>
+class __simd_storage {};
+
+template <class _Tp, int __num_element>
+class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {
+  std::array<_Tp, __num_element> __storage_;
+
+  template <class, class>
+  friend struct simd;
+
+  template <class, class>
+  friend struct simd_mask;
+
+public:
+  _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };
+  void __set(size_t __index, _Tp __val) noexcept {
+    __storage_[__index] = __val;
+  }
+};
+
+template <class _Tp>
+class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {
+  _Tp __storage_;
+
+  template <class, class>
+  friend struct simd;
+
+  template <class, class>
+  friend struct simd_mask;
+
+public:
+  _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; };
+  void __set(size_t __index, _Tp __val) noexcept {
+    (&__storage_)[__index] = __val;
+  }
+};
+
+#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+
+constexpr size_t __floor_pow_of_2(size_t __val) {
+  return ((__val - 1) & __val) == 0 ? __val
+                                    : __floor_pow_of_2((__val - 1) & __val);
+}
+
+constexpr size_t __ceil_pow_of_2(size_t __val) {
+  return __val == 1 ? 1 : __floor_pow_of_2(__val - 1) << 1;
+}
+
+template <class _Tp, size_t __bytes>
+struct __vec_ext_traits {
+#if !defined(_LIBCUDACXX_COMPILER_CLANG)
+  typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes))));
+#endif
+};
+
+#if defined(_LIBCUDACXX_COMPILER_CLANG)
+#define _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT)                        \
+  template <>                                                                  \
+  struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> {               \
+    using type =                                                               \
+        _TYPE __attribute__((vector_size(sizeof(_TYPE) * _NUM_ELEMENT)));      \
+  }
+
+#define _LIBCUDACXX_SPECIALIZE_VEC_EXT_32(_TYPE)                                   \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 1);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 2);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 3);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 4);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 5);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 6);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 7);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 8);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 9);                                        \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 10);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 11);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 12);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 13);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 14);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 15);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 16);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 17);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 18);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 19);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 20);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 21);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 22);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 23);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 24);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 25);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 26);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 27);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 28);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 29);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 30);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 31);                                       \
+  _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 32);
+
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char16_t);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char32_t);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(wchar_t);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed char);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed short);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed int);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long long);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned char);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned short);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned int);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long long);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(float);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(double);
+_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(long double);
+
+#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT_32
+#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT
+#endif
+
+template <class _Tp, int __num_element>
+class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> {
+  using _StorageType =
+      typename __vec_ext_traits<_Tp, sizeof(_Tp) * __num_element>::type;
+
+  _StorageType __storage_;
+
+  template <class, class>
+  friend struct simd;
+
+  template <class, class>
+  friend struct simd_mask;
+
+public:
+  _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };
+  void __set(size_t __index, _Tp __val) noexcept {
+    __storage_[__index] = __val;
+  }
+};
+
+#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+
+template <class _Vp, class _Tp, class _Abi>
+class __simd_reference {
+  static_assert(std::is_same<_Vp, _Tp>::value, "");
+
+  template <class, class>
+  friend struct simd;
+
+  template <class, class>
+  friend struct simd_mask;
+
+  __simd_storage<_Tp, _Abi>* __ptr_;
+  size_t __index_;
+
+  __simd_reference(__simd_storage<_Tp, _Abi>* __ptr, size_t __index)
+      : __ptr_(__ptr), __index_(__index) {}
+
+  __simd_reference(const __simd_reference&) = default;
+
+public:
+  __simd_reference() = delete;
+  __simd_reference& operator=(const __simd_reference&) = delete;
+
+  operator _Vp() const { return __ptr_->__get(__index_); }
+
+  __simd_reference operator=(_Vp __value) && {
+    __ptr_->__set(__index_, __value);
+    return *this;
+  }
+
+  __simd_reference operator++() && {
+    return std::move(*this) = __ptr_->__get(__index_) + 1;
+  }
+
+  _Vp operator++(int) && {
+    auto __val = __ptr_->__get(__index_);
+    __ptr_->__set(__index_, __val + 1);
+    return __val;
+  }
+
+  __simd_reference operator--() && {
+    return std::move(*this) = __ptr_->__get(__index_) - 1;
+  }
+
+  _Vp operator--(int) && {
+    auto __val = __ptr_->__get(__index_);
+    __ptr_->__set(__index_, __val - 1);
+    return __val;
+  }
+
+  __simd_reference operator+=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) + __value;
+  }
+
+  __simd_reference operator-=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) - __value;
+  }
+
+  __simd_reference operator*=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) * __value;
+  }
+
+  __simd_reference operator/=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) / __value;
+  }
+
+  __simd_reference operator%=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) % __value;
+  }
+
+  __simd_reference operator>>=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) >> __value;
+  }
+
+  __simd_reference operator<<=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) << __value;
+  }
+
+  __simd_reference operator&=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) & __value;
+  }
+
+  __simd_reference operator|=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) | __value;
+  }
+
+  __simd_reference operator^=(_Vp __value) && {
+    return std::move(*this) = __ptr_->__get(__index_) ^ __value;
+  }
+};
+
+template <class _To, class _From>
+constexpr decltype(_To{std::declval<_From>()}, true)
+__is_non_narrowing_convertible_impl(_From) {
+  return true;
+}
+
+template <class _To>
+constexpr bool __is_non_narrowing_convertible_impl(...) {
+  return false;
+}
+
+template <class _From, class _To>
+constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&
+                                      std::is_arithmetic<_From>::value,
+                                  bool>::type
+__is_non_narrowing_arithmetic_convertible() {
+  return __is_non_narrowing_convertible_impl<_To>(_From{});
+}
+
+template <class _From, class _To>
+constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&
+                                    std::is_arithmetic<_From>::value),
+                                  bool>::type
+__is_non_narrowing_arithmetic_convertible() {
+  return false;
+}
+
+template <class _Tp>
+constexpr _Tp __variadic_sum() {
+  return _Tp{};
+}
+
+template <class _Tp, class _Up, class... _Args>
+constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {
+  return static_cast<_Tp>(__first) + __variadic_sum<_Tp>(__rest...);
+}
+
+template <class _Tp>
+struct __nodeduce {
+  using type = _Tp;
+};
+
+template <class _Tp>
+constexpr bool __vectorizable() {
+  return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value &&
+         !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value;
+}
+
+_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD
+_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+
+using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
+
+template <int _Np>
+using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr size_t max_fixed_size = 32;
+
+template <class _Tp>
+using compatible = fixed_size<16 / sizeof(_Tp)>;
+
+#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+template <class _Tp>
+using native = __simd_abi<_StorageKind::_VecExt,
+                          _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+#else
+template <class _Tp>
+using native =
+    fixed_size<_Tp, _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+
+_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+class simd;
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+class simd_mask;
+
+struct element_aligned_tag {};
+struct vector_aligned_tag {};
+template <size_t>
+struct overaligned_tag {};
+_LIBCUDACXX_INLINE_VAR constexpr element_aligned_tag element_aligned{};
+_LIBCUDACXX_INLINE_VAR constexpr vector_aligned_tag vector_aligned{};
+template <size_t _Np>
+_LIBCUDACXX_INLINE_VAR constexpr overaligned_tag<_Np> overaligned{};
+
+// traits [simd.traits]
+template <class _Tp>
+struct is_abi_tag : std::integral_constant<bool, false> {};
+
+template <_StorageKind __kind, int _Np>
+struct is_abi_tag<__simd_abi<__kind, _Np>>
+    : std::integral_constant<bool, true> {};
+
+template <class _Tp>
+struct is_simd : std::integral_constant<bool, false> {};
+
+template <class _Tp, class _Abi>
+struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};
+
+template <class _Tp>
+struct is_simd_mask : std::integral_constant<bool, false> {};
+
+template <class _Tp, class _Abi>
+struct is_simd_mask<simd_mask<_Tp, _Abi>> : std::integral_constant<bool, true> {
+};
+
+template <class _Tp>
+struct is_simd_flag_type : std::integral_constant<bool, false> {};
+
+template <>
+struct is_simd_flag_type<element_aligned_tag>
+    : std::integral_constant<bool, true> {};
+
+template <>
+struct is_simd_flag_type<vector_aligned_tag>
+    : std::integral_constant<bool, true> {};
+
+template <size_t _Align>
+struct is_simd_flag_type<overaligned_tag<_Align>>
+    : std::integral_constant<bool, true> {};
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_v = is_simd<_Tp>::value;
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
+template <class _Tp>
+_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_flag_type_v =
+    is_simd_flag_type<_Tp>::value;
+template <class _Tp, size_t _Np>
+struct abi_for_size {
+  using type = simd_abi::fixed_size<_Np>;
+};
+template <class _Tp, size_t _Np>
+using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+struct simd_size;
+
+template <class _Tp, _StorageKind __kind, int _Np>
+struct simd_size<_Tp, __simd_abi<__kind, _Np>>
+    : std::integral_constant<size_t, _Np> {
+  static_assert(
+      std::is_arithmetic<_Tp>::value &&
+          !std::is_same<typename std::remove_const<_Tp>::type, bool>::value,
+      "Element type should be vectorizable");
+};
+
+// TODO: implement it.
+template <class _Tp, class _Up = typename _Tp::value_type>
+struct memory_alignment;
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+_LIBCUDACXX_INLINE_VAR constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
+
+template <class _Tp, class _Up = typename _Tp::value_type>
+_LIBCUDACXX_INLINE_VAR constexpr size_t memory_alignment_v =
+    memory_alignment<_Tp, _Up>::value;
+
+// class template simd [simd.class]
+template <class _Tp>
+using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
+template <class _Tp, int _Np>
+using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
+
+// class template simd_mask [simd.mask.class]
+template <class _Tp>
+using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
+
+template <class _Tp, int _Np>
+using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
+
+// casts [simd.casts]
+template <class _Tp>
+struct __static_simd_cast_traits {
+  template <class _Up, class _Abi>
+  static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);
+};
+
+template <class _Tp, class _NewAbi>
+struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {
+  template <class _Up, class _Abi>
+  static typename std::enable_if<simd<_Up, _Abi>::size() ==
+                                     simd<_Tp, _NewAbi>::size(),
+                                 simd<_Tp, _NewAbi>>::type
+  __apply(const simd<_Up, _Abi>& __v);
+};
+
+template <class _Tp>
+struct __simd_cast_traits {
+  template <class _Up, class _Abi>
+  static typename std::enable_if<
+      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),
+      simd<_Tp, _Abi>>::type
+  __apply(const simd<_Up, _Abi>& __v);
+};
+
+template <class _Tp, class _NewAbi>
+struct __simd_cast_traits<simd<_Tp, _NewAbi>> {
+  template <class _Up, class _Abi>
+  static typename std::enable_if<
+      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&
+          simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),
+      simd<_Tp, _NewAbi>>::type
+  __apply(const simd<_Up, _Abi>& __v);
+};
+
+template <class _Tp, class _Up, class _Abi>
+auto simd_cast(const simd<_Up, _Abi>& __v)
+    -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {
+  return __simd_cast_traits<_Tp>::__apply(__v);
+}
+
+template <class _Tp, class _Up, class _Abi>
+auto static_simd_cast(const simd<_Up, _Abi>& __v)
+    -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {
+  return __static_simd_cast_traits<_Tp>::__apply(__v);
+}
+
+template <class _Tp, class _Abi>
+fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
+to_fixed_size(const simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, size_t _Np>
+native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;
+
+template <class _Tp, size_t _Np>
+native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
+
+template <class _Tp, size_t _Np>
+simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;
+
+template <class _Tp, size_t _Np>
+simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
+
+template <size_t... __sizes, class _Tp, class _Abi>
+tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);
+
+template <size_t... __sizes, class _Tp, class _Abi>
+tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>
+split(const simd_mask<_Tp, _Abi>&);
+
+template <class _SimdType, class _Abi>
+array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
+                     _SimdType::size()>
+split(const simd<typename _SimdType::value_type, _Abi>&);
+
+template <class _SimdType, class _Abi>
+array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
+                     _SimdType::size()>
+split(const simd_mask<typename _SimdType::value_type, _Abi>&);
+
+template <class _Tp, class... _Abis>
+simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
+concat(const simd<_Tp, _Abis>&...);
+
+template <class _Tp, class... _Abis>
+simd_mask<_Tp,
+          abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
+concat(const simd_mask<_Tp, _Abis>&...);
+
+// reductions [simd.mask.reductions]
+template <class _Tp, class _Abi>
+bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template <class _Tp, class _Abi>
+bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template <class _Tp, class _Abi>
+bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template <class _Tp, class _Abi>
+bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template <class _Tp, class _Abi>
+int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
+template <class _Tp, class _Abi>
+int find_first_set(const simd_mask<_Tp, _Abi>&);
+template <class _Tp, class _Abi>
+int find_last_set(const simd_mask<_Tp, _Abi>&);
+bool all_of(bool) noexcept;
+bool any_of(bool) noexcept;
+bool none_of(bool) noexcept;
+bool some_of(bool) noexcept;
+int popcount(bool) noexcept;
+int find_first_set(bool) noexcept;
+int find_last_set(bool) noexcept;
+
+// masked assignment [simd.whereexpr]
+template <class _MaskType, class _Tp>
+class const_where_expression;
+template <class _MaskType, class _Tp>
+class where_expression;
+
+// masked assignment [simd.mask.where]
+template <class _Tp, class _Abi>
+where_expression<simd_mask<_Tp, _Abi>, simd<_Tp, _Abi>>
+where(const typename simd<_Tp, _Abi>::mask_type&, simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+const_where_expression<simd_mask<_Tp, _Abi>, const simd<_Tp, _Abi>>
+where(const typename simd<_Tp, _Abi>::mask_type&,
+      const simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+where_expression<simd_mask<_Tp, _Abi>, simd_mask<_Tp, _Abi>>
+where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
+      simd_mask<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+const_where_expression<simd_mask<_Tp, _Abi>, const simd_mask<_Tp, _Abi>>
+where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
+      const simd_mask<_Tp, _Abi>&) noexcept;
+
+template <class _Tp>
+where_expression<bool, _Tp> where(bool, _Tp&) noexcept;
+
+template <class _Tp>
+const_where_expression<bool, const _Tp> where(bool, const _Tp&) noexcept;
+
+// reductions [simd.reductions]
+template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
+_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
+
+template <class _MaskType, class _SimdType, class _BinaryOp>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       typename _SimdType::value_type neutral_element, _BinaryOp binary_op);
+
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       plus<typename _SimdType::value_type> binary_op = {});
+
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       multiplies<typename _SimdType::value_type> binary_op);
+
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       bit_and<typename _SimdType::value_type> binary_op);
+
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       bit_or<typename _SimdType::value_type> binary_op);
+
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+reduce(const const_where_expression<_MaskType, _SimdType>&,
+       bit_xor<typename _SimdType::value_type> binary_op);
+
+template <class _Tp, class _Abi>
+_Tp hmin(const simd<_Tp, _Abi>&);
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+hmin(const const_where_expression<_MaskType, _SimdType>&);
+template <class _Tp, class _Abi>
+_Tp hmax(const simd<_Tp, _Abi>&);
+template <class _MaskType, class _SimdType>
+typename _SimdType::value_type
+hmax(const const_where_expression<_MaskType, _SimdType>&);
+
+// algorithms [simd.alg]
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+std::pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
+minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+
+template <class _Tp, class _Abi>
+simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&,
+                      const simd<_Tp, _Abi>&);
+
+// [simd.whereexpr]
+// TODO implement where expressions.
+template <class _MaskType, class _Tp>
+class const_where_expression {
+public:
+  const_where_expression(const const_where_expression&) = delete;
+  const_where_expression& operator=(const const_where_expression&) = delete;
+  __remove_const_t<_Tp> operator-() const&&;
+  template <class _Up, class _Flags>
+  void copy_to(_Up*, _Flags) const&&;
+};
+
+template <class _MaskType, class _Tp>
+class where_expression : public const_where_expression<_MaskType, _Tp> {
+public:
+  where_expression(const where_expression&) = delete;
+  where_expression& operator=(const where_expression&) = delete;
+  template <class _Up>
+  void operator=(_Up&&);
+  template <class _Up>
+  void operator+=(_Up&&);
+  template <class _Up>
+  void operator-=(_Up&&);
+  template <class _Up>
+  void operator*=(_Up&&);
+  template <class _Up>
+  void operator/=(_Up&&);
+  template <class _Up>
+  void operator%=(_Up&&);
+  template <class _Up>
+  void operator&=(_Up&&);
+  template <class _Up>
+  void operator|=(_Up&&);
+  template <class _Up>
+  void operator^=(_Up&&);
+  template <class _Up>
+  void operator<<=(_Up&&);
+  template <class _Up>
+  void operator>>=(_Up&&);
+  void operator++();
+  void operator++(int);
+  void operator--();
+  void operator--(int);
+  template <class _Up, class _Flags>
+  void copy_from(const _Up*, _Flags);
+};
+
+// [simd.class]
+// TODO: implement simd
+template <class _Tp, class _Abi>
+class simd {
+public:
+  using value_type = _Tp;
+  using reference = __simd_reference<_Tp, _Tp, _Abi>;
+  using mask_type = simd_mask<_Tp, _Abi>;
+  using abi_type = _Abi;
+
+  simd() = default;
+  simd(const simd&) = default;
+  simd& operator=(const simd&) = default;
+
+  static constexpr size_t size() noexcept {
+    return simd_size<_Tp, _Abi>::value;
+  }
+
+private:
+  __simd_storage<_Tp, _Abi> __s_;
+
+  template <class _Up>
+  static constexpr bool __can_broadcast() {
+    return (std::is_arithmetic<_Up>::value &&
+            __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
+           (!std::is_arithmetic<_Up>::value &&
+            std::is_convertible<_Up, _Tp>::value) ||
+           std::is_same<typename std::remove_const<_Up>::type, int>::value ||
+           (std::is_same<typename std::remove_const<_Up>::type,
+                         unsigned int>::value &&
+            std::is_unsigned<_Tp>::value);
+  }
+
+  template <class _Generator, size_t... __indicies>
+  static constexpr decltype(
+      std::forward_as_tuple(std::declval<_Generator>()(
+          std::integral_constant<size_t, __indicies>())...),
+      bool())
+  __can_generate(std::index_sequence<__indicies...>) {
+    return !__variadic_sum<bool>(
+        !__can_broadcast<decltype(std::declval<_Generator>()(
+            std::integral_constant<size_t, __indicies>()))>()...);
+  }
+
+  template <class _Generator>
+  static bool __can_generate(...) {
+    return false;
+  }
+
+  template <class _Generator, size_t... __indicies>
+  void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) {
+    int __not_used[]{((*this)[__indicies] =
+                          __g(std::integral_constant<size_t, __indicies>()),
+                      0)...};
+    (void)__not_used;
+  }
+
+public:
+  // implicit type conversion constructor
+  template <class _Up,
+            class = typename std::enable_if<
+                std::is_same<_Abi, simd_abi::fixed_size<size()>>::value &&
+                __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()>::type>
+  simd(const simd<_Up, simd_abi::fixed_size<size()>>& __v) {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = static_cast<_Tp>(__v[__i]);
+    }
+  }
+
+  // implicit broadcast constructor
+  template <class _Up,
+            class = typename std::enable_if<__can_broadcast<_Up>()>::type>
+  simd(_Up&& __rv) {
+    auto __v = static_cast<_Tp>(__rv);
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = __v;
+    }
+  }
+
+  // generator constructor
+  template <class _Generator,
+            int = typename std::enable_if<
+                __can_generate<_Generator>(std::make_index_sequence<size()>()),
+                int>::type()>
+  explicit simd(_Generator&& __g) {
+    __generator_init(std::forward<_Generator>(__g),
+                     std::make_index_sequence<size()>());
+  }
+
+  // load constructor
+  template <
+      class _Up, class _Flags,
+      class = typename std::enable_if<__vectorizable<_Up>()>::type,
+      class = typename std::enable_if<is_simd_flag_type<_Flags>::value>::type>
+  simd(const _Up* __buffer, _Flags) {
+    // TODO: optimize for overaligned flags
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = static_cast<_Tp>(__buffer[__i]);
+    }
+  }
+
+  // loads [simd.load]
+  template <class _Up, class _Flags>
+  typename std::enable_if<__vectorizable<_Up>() &&
+                          is_simd_flag_type<_Flags>::value>::type
+  copy_from(const _Up* __buffer, _Flags) {
+    *this = simd(__buffer, _Flags());
+  }
+
+  // stores [simd.store]
+  template <class _Up, class _Flags>
+  typename std::enable_if<__vectorizable<_Up>() &&
+                          is_simd_flag_type<_Flags>::value>::type
+  copy_to(_Up* __buffer, _Flags) const {
+    // TODO: optimize for overaligned flags
+    for (size_t __i = 0; __i < size(); __i++) {
+      __buffer[__i] = static_cast<_Up>((*this)[__i]);
+    }
+  }
+
+  // scalar access [simd.subscr]
+  reference operator[](size_t __i) { return reference(&__s_, __i); }
+
+  value_type operator[](size_t __i) const { return __s_.__get(__i); }
+
+  // unary operators [simd.unary]
+  simd& operator++();
+  simd operator++(int);
+  simd& operator--();
+  simd operator--(int);
+  mask_type operator!() const;
+  simd operator~() const;
+  simd operator+() const;
+  simd operator-() const;
+
+  // binary operators [simd.binary]
+  friend simd operator+(const simd&, const simd&);
+  friend simd operator-(const simd&, const simd&);
+  friend simd operator*(const simd&, const simd&);
+  friend simd operator/(const simd&, const simd&);
+  friend simd operator%(const simd&, const simd&);
+  friend simd operator&(const simd&, const simd&);
+  friend simd operator|(const simd&, const simd&);
+  friend simd operator^(const simd&, const simd&);
+  friend simd operator<<(const simd&, const simd&);
+  friend simd operator>>(const simd&, const simd&);
+  friend simd operator<<(const simd&, int);
+  friend simd operator>>(const simd&, int);
+
+  // compound assignment [simd.cassign]
+  friend simd& operator+=(simd&, const simd&);
+  friend simd& operator-=(simd&, const simd&);
+  friend simd& operator*=(simd&, const simd&);
+  friend simd& operator/=(simd&, const simd&);
+  friend simd& operator%=(simd&, const simd&);
+
+  friend simd& operator&=(simd&, const simd&);
+  friend simd& operator|=(simd&, const simd&);
+  friend simd& operator^=(simd&, const simd&);
+  friend simd& operator<<=(simd&, const simd&);
+  friend simd& operator>>=(simd&, const simd&);
+  friend simd& operator<<=(simd&, int);
+  friend simd& operator>>=(simd&, int);
+
+  // compares [simd.comparison]
+  friend mask_type operator==(const simd&, const simd&);
+  friend mask_type operator!=(const simd&, const simd&);
+  friend mask_type operator>=(const simd&, const simd&);
+  friend mask_type operator<=(const simd&, const simd&);
+  friend mask_type operator>(const simd&, const simd&);
+  friend mask_type operator<(const simd&, const simd&);
+};
+
+// [simd.mask.class]
+template <class _Tp, class _Abi>
+// TODO: implement simd_mask
+class simd_mask {
+public:
+  using value_type = bool;
+  // TODO: this is strawman implementation. Turn it into a proxy type.
+  using reference = bool&;
+  using simd_type = simd<_Tp, _Abi>;
+  using abi_type = _Abi;
+  static constexpr size_t size() noexcept;
+  simd_mask() = default;
+
+  // broadcast constructor
+  explicit simd_mask(value_type) noexcept;
+
+  // implicit type conversion constructor
+  template <class _Up>
+  simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&) noexcept;
+
+  // load constructor
+  template <class _Flags>
+  simd_mask(const value_type*, _Flags);
+
+  // loads [simd.mask.copy]
+  template <class _Flags>
+  void copy_from(const value_type*, _Flags);
+  template <class _Flags>
+  void copy_to(value_type*, _Flags) const;
+
+  // scalar access [simd.mask.subscr]
+  reference operator[](size_t);
+  value_type operator[](size_t) const;
+
+  // unary operators [simd.mask.unary]
+  simd_mask operator!() const noexcept;
+
+  // simd_mask binary operators [simd.mask.binary]
+  friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept;
+  friend simd_mask operator|(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept;
+
+  // simd_mask compound assignment [simd.mask.cassign]
+  friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
+
+  // simd_mask compares [simd.mask.comparison]
+  friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
+  friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
+};
+
+#endif // _LIBCUDACXX_STD_VER >= 17
+
+_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_SIMD */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/string b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/string
new file mode 100644
index 0000000000000000000000000000000000000000..0e502e823b3fcc8ce8103bf701a33890ba6936e8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/string
@@ -0,0 +1,61 @@
+// -*- C++ -*-
+//===--------------------------- string ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_STRING
+#define _LIBCUDACXX_EXPERIMENTAL_STRING
+/*
+    experimental/string synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  // basic_string using polymorphic allocator in namespace pmr
+  template <class charT, class traits = char_traits<charT>>
+   using basic_string =
+     std::basic_string<charT, traits, polymorphic_allocator<charT>>;
+
+  // basic_string typedef names using polymorphic allocator in namespace
+  // std::experimental::pmr
+  typedef basic_string<char> string;
+  typedef basic_string<char16_t> u16string;
+  typedef basic_string<char32_t> u32string;
+  typedef basic_string<wchar_t> wstring;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <string>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _CharT, class _Traits = char_traits<_CharT>>
+using basic_string =
+    _CUDA_VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+
+typedef basic_string<char> string;
+typedef basic_string<char16_t> u16string;
+typedef basic_string<char32_t> u32string;
+typedef basic_string<wchar_t> wstring;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_STRING */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits
new file mode 100644
index 0000000000000000000000000000000000000000..81555c2b2968bb638f91f6d6010d86901034b193
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/type_traits
@@ -0,0 +1,154 @@
+// -*- C++ -*-
+//===-------------------------- type_traits -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS
+#define _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS
+
+/**
+    experimental/type_traits synopsis
+
+// C++1y
+#include <type_traits>
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+
+  // 3.3.2, Other type transformations
+  template <class> class invocation_type; // not defined
+  template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>;
+  template <class> class raw_invocation_type; // not defined
+  template <class F, class... ArgTypes> class raw_invocation_type<F(ArgTypes...)>;
+
+  template <class T>
+    using invocation_type_t = typename invocation_type<T>::type;
+  template <class T>
+    using raw_invocation_type_t = typename raw_invocation_type<T>::type;
+
+  // 3.3.4, Detection idiom
+  template <class...> using void_t = void;
+
+  struct nonesuch {
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    void operator=(nonesuch const&) = delete;
+  };
+
+  template <template<class...> class Op, class... Args>
+    using is_detected = see below;
+  template <template<class...> class Op, class... Args>
+    constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+  template <template<class...> class Op, class... Args>
+    using detected_t = see below;
+  template <class Default, template<class...> class Op, class... Args>
+    using detected_or = see below;
+  template <class Default, template<class...> class Op, class... Args>
+    using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+  template <class Expected, template<class...> class Op, class... Args>
+    using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>;
+  template <class Expected, template<class...> class Op, class... Args>
+    constexpr bool is_detected_exact_v
+      = is_detected_exact<Expected, Op, Args...>::value;
+  template <class To, template<class...> class Op, class... Args>
+     using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
+  template <class To, template<class...> class Op, class... Args>
+     constexpr bool is_detected_convertible_v
+       = is_detected_convertible<To, Op, Args...>::value;  
+
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#include <initializer_list>
+#include <type_traits>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+// 3.3.2, Other type transformations
+/*
+template <class>
+class _LIBCUDACXX_TEMPLATE_VIS raw_invocation_type;
+
+template <class _Fn, class ..._Args>
+class _LIBCUDACXX_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>;
+
+template <class>
+class _LIBCUDACXX_TEMPLATE_VIS invokation_type;
+
+template <class _Fn, class ..._Args>
+class _LIBCUDACXX_TEMPLATE_VIS invokation_type<_Fn(_Args...)>;
+
+template <class _Tp>
+using invokation_type_t = typename invokation_type<_Tp>::type;
+
+template <class _Tp>
+using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
+*/
+
+// 3.3.4, Detection idiom
+template <class...> using void_t = void;
+
+struct nonesuch : private _CUDA_VSTD::__nat { // make nonesuch "not an aggregate"
+  ~nonesuch() = delete;
+  nonesuch      (nonesuch const&) = delete;
+  void operator=(nonesuch const&) = delete;
+  };
+
+template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args>
+struct _DETECTOR {
+   using value_t = false_type;
+   using type = _Default;
+   };
+
+template <class _Default, template <class...> class _Op, class... _Args>
+struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
+   using value_t = true_type;
+   using type = _Op<_Args...>;
+   };
+     
+
+template <template<class...> class _Op, class... _Args>
+  using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
+template <template<class...> class _Op, class... _Args>
+  using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
+template <template<class...> class _Op, class... _Args>
+  _LIBCUDACXX_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;
+
+template <class Default, template<class...> class _Op, class... _Args>
+  using detected_or = _DETECTOR<Default, void, _Op, _Args...>;
+template <class Default, template<class...> class _Op, class... _Args>
+  using detected_or_t = typename detected_or<Default, _Op, _Args...>::type;
+
+template <class Expected, template<class...> class _Op, class... _Args>
+  using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>;
+template <class Expected, template<class...> class _Op, class... _Args>
+  _LIBCUDACXX_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value;
+
+template <class To, template<class...> class _Op, class... _Args>
+  using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
+template <class To, template<class...> class _Op, class... _Args>
+  _LIBCUDACXX_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;  
+
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+#endif /* _LIBCUDACXX_STD_VER > 11 */
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_TYPE_TRAITS */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map
new file mode 100644
index 0000000000000000000000000000000000000000..221156a3e84b733508447f28d66260711e0268f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_map
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+//===------------------------- unordered_map ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP
+#define _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP
+/*
+    experimental/unordered_map synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class Key, class T,
+            class Hash = hash<Key>,
+            class Pred = equal_to<Key>>
+  using unordered_map =
+    std::unordered_map<Key, T, Hash, Pred,
+                       polymorphic_allocator<pair<const Key,T>>>;
+
+  template <class Key, class T,
+            class Hash = hash<Key>,
+            class Pred = equal_to<Key>>
+  using unordered_multimap =
+    std::unordered_multimap<Key, T, Hash, Pred,
+                            polymorphic_allocator<pair<const Key,T>>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <unordered_map>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Key, class _Value,
+          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
+using unordered_map = _CUDA_VSTD::unordered_map<_Key, _Value, _Hash, _Pred,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+template <class _Key, class _Value,
+          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
+using unordered_multimap = _CUDA_VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred,
+                        polymorphic_allocator<pair<const _Key, _Value>>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_UNORDERED_MAP */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_set b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_set
new file mode 100644
index 0000000000000000000000000000000000000000..2c3243e06c71ec7816b88e391db1c1427d5748db
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/unordered_set
@@ -0,0 +1,58 @@
+// -*- C++ -*-
+//===------------------------- unordered_set ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_UNORDERED_SET
+#define _LIBCUDACXX_EXPERIMENTAL_UNORDERED_SET
+/*
+    experimental/unordered_set synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
+  using unordered_set = std::unordered_set<T, Hash, Pred,
+                       polymorphic_allocator<T>>;
+
+  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
+  using unordered_multiset = std::unordered_multiset<T, Hash, Pred,
+                       polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <unordered_set>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _Value,
+          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
+using unordered_set = _CUDA_VSTD::unordered_set<_Value, _Hash, _Pred,
+                        polymorphic_allocator<_Value>>;
+
+template <class _Value,
+          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
+using unordered_multiset = _CUDA_VSTD::unordered_multiset<_Value, _Hash, _Pred,
+                        polymorphic_allocator<_Value>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_UNORDERED_SET */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/utility b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/utility
new file mode 100644
index 0000000000000000000000000000000000000000..8f7f7a149d9fcac076a7f994787b239db2c0d734
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/utility
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===-------------------------- utility ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_UTILITY
+#define _LIBCUDACXX_EXPERIMENTAL_UTILITY
+
+/*
+    experimental/utility synopsis
+
+// C++1y
+
+#include <utility>
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+
+  3.1.2, erased-type placeholder
+  struct erased_type { };
+
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <utility>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS
+
+  struct _LIBCUDACXX_TEMPLATE_VIS erased_type { };
+
+_LIBCUDACXX_END_NAMESPACE_LFTS
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_UTILITY */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/vector b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/vector
new file mode 100644
index 0000000000000000000000000000000000000000..d3c593467c5599e21ee93fecea716f03f4b2152c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/experimental/vector
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===--------------------------- vector ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXPERIMENTAL_VECTOR
+#define _LIBCUDACXX_EXPERIMENTAL_VECTOR
+/*
+    experimental/vector synopsis
+
+// C++1z
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+namespace pmr {
+
+  template <class T>
+  using vector = std::vector<T, polymorphic_allocator<T>>;
+
+} // namespace pmr
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+#include <experimental/__config>
+#include <vector>
+#include <experimental/memory_resource>
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_LFTS_PMR
+
+template <class _ValueT>
+using vector = _CUDA_VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
+
+_LIBCUDACXX_END_NAMESPACE_LFTS_PMR
+
+#endif /* _LIBCUDACXX_EXPERIMENTAL_VECTOR */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/__hash b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/__hash
new file mode 100644
index 0000000000000000000000000000000000000000..18389b2f7b30450fd2f578dbffc40542b1c01a66
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/__hash
@@ -0,0 +1,133 @@
+// -*- C++ -*-
+//===------------------------- hash_set ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_EXT_HASH
+#define _LIBCUDACXX_EXT_HASH
+
+#pragma GCC system_header
+
+#include <string>
+#include <cstring>
+
+namespace __gnu_cxx {
+
+template <typename _Tp> struct _LIBCUDACXX_TEMPLATE_VIS hash { };
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<const char*>
+ : public std::__unary_function<const char*, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(const char *__c) const _NOEXCEPT
+    {
+        return std::__do_string_hash(__c, __c + strlen(__c));
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<char *>
+ : public std::__unary_function<char*, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(char *__c) const _NOEXCEPT
+    {
+        return std::__do_string_hash<const char *>(__c, __c + strlen(__c));
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<char>
+ : public std::__unary_function<char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(char __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<signed char>
+ : public std::__unary_function<signed char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(signed char __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned char>
+ : public std::__unary_function<unsigned char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned char __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<short>
+ : public std::__unary_function<short, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(short __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned short>
+ : public std::__unary_function<unsigned short, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned short __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<int>
+    : public std::__unary_function<int, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(int __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned int>
+    : public std::__unary_function<unsigned int, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned int __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<long>
+    : public std::__unary_function<long, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(long __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+
+template <> struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned long>
+    : public std::__unary_function<unsigned long, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned long __c) const _NOEXCEPT
+    {
+        return __c;
+    }
+};
+}
+
+#endif  // _LIBCUDACXX_EXT_HASH
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_map b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_map
new file mode 100644
index 0000000000000000000000000000000000000000..799df8a50fcf2bc77ceec1ca8b14c52a00661a49
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_map
@@ -0,0 +1,984 @@
+// -*- C++ -*-
+//===-------------------------- hash_map ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_HASH_MAP
+#define _LIBCUDACXX_HASH_MAP
+
+/*
+
+    hash_map synopsis
+
+namespace __gnu_cxx
+{
+
+template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+          class Alloc = allocator<pair<const Key, T>>>
+class hash_map
+{
+public:
+    // types
+    typedef Key                                                        key_type;
+    typedef T                                                          mapped_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef pair<const key_type, mapped_type>                          value_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    hash_map();
+    explicit hash_map(size_type n, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+    hash_map(InputIterator f, InputIterator l);
+    template <class InputIterator>
+    hash_map(InputIterator f, InputIterator l,
+                size_type n, const hasher& hf = hasher(),
+                const key_equal& eql = key_equal(),
+                const allocator_type& a = allocator_type());
+    hash_map(const hash_map&);
+    ~hash_map();
+    hash_map& operator=(const hash_map&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    pair<iterator, bool> insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_map&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    mapped_type& operator[](const key_type& k);
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(hash_map<Key, T, Hash, Pred, Alloc>& x,
+              hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_map<Key, T, Hash, Pred, Alloc>& x,
+               const hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_map<Key, T, Hash, Pred, Alloc>& x,
+               const hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+          class Alloc = allocator<pair<const Key, T>>>
+class hash_multimap
+{
+public:
+    // types
+    typedef Key                                                        key_type;
+    typedef T                                                          mapped_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef pair<const key_type, mapped_type>                          value_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_multimap(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_multimap(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    explicit hash_multimap(const allocator_type&);
+    hash_multimap(const hash_multimap&);
+    ~hash_multimap();
+    hash_multimap& operator=(const hash_multimap&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    iterator insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_multimap&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+              hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+               const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+               const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+}  // __gnu_cxx
+
+*/
+
+#include <__config>
+#include <__hash_table>
+#include <functional>
+#include <stdexcept>
+#include <type_traits>
+#include <ext/__hash>
+
+#if __DEPRECATED
+#if defined(_LIBCUDACXX_WARNING)
+    _LIBCUDACXX_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
+#else
+#   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
+#endif
+#endif
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+namespace __gnu_cxx {
+
+template <class _Tp, class _Hash,
+          bool = std::is_empty<_Hash>::value && !std::__libcpp_is_final<_Hash>::value
+        >
+class __hash_map_hasher
+    : private _Hash
+{
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_hasher() : _Hash() {}
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
+    _LIBCUDACXX_INLINE_VISIBILITY const _Hash& hash_function() const {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(const _Tp& __x) const
+        {return static_cast<const _Hash&>(*this)(__x.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(const typename _Tp::first_type& __x) const
+        {return static_cast<const _Hash&>(*this)(__x);}
+};
+
+template <class _Tp, class _Hash>
+class __hash_map_hasher<_Tp, _Hash, false>
+{
+    _Hash __hash_;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_hasher() : __hash_() {}
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
+    _LIBCUDACXX_INLINE_VISIBILITY const _Hash& hash_function() const {return __hash_;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(const _Tp& __x) const
+        {return __hash_(__x.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(const typename _Tp::first_type& __x) const
+        {return __hash_(__x);}
+};
+
+template <class _Tp, class _Pred,
+          bool = std::is_empty<_Pred>::value && !std::__libcpp_is_final<_Pred>::value
+         >
+class __hash_map_equal
+    : private _Pred
+{
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_equal() : _Pred() {}
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
+    _LIBCUDACXX_INLINE_VISIBILITY const _Pred& key_eq() const {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return static_cast<const _Pred&>(*this)(__x.first, __y.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
+        {return static_cast<const _Pred&>(*this)(__x, __y.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
+        {return static_cast<const _Pred&>(*this)(__x.first, __y);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const typename _Tp::first_type& __x,
+                    const typename _Tp::first_type& __y) const
+        {return static_cast<const _Pred&>(*this)(__x, __y);}
+};
+
+template <class _Tp, class _Pred>
+class __hash_map_equal<_Tp, _Pred, false>
+{
+    _Pred __pred_;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_equal() : __pred_() {}
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_equal(const _Pred& __p) : __pred_(__p) {}
+    _LIBCUDACXX_INLINE_VISIBILITY const _Pred& key_eq() const {return __pred_;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __pred_(__x.first, __y.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const
+        {return __pred_(__x, __y.first);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const
+        {return __pred_(__x.first, __y);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const typename _Tp::first_type& __x,
+                    const typename _Tp::first_type& __y) const
+        {return __pred_(__x, __y);}
+};
+
+template <class _Alloc>
+class __hash_map_node_destructor
+{
+    typedef _Alloc                              allocator_type;
+    typedef std::allocator_traits<allocator_type>    __alloc_traits;
+    typedef typename __alloc_traits::value_type::__node_value_type value_type;
+public:
+    typedef typename __alloc_traits::pointer    pointer;
+private:
+    typedef typename value_type::first_type     first_type;
+    typedef typename value_type::second_type    second_type;
+
+    allocator_type& __na_;
+
+public:
+    bool __first_constructed;
+    bool __second_constructed;
+
+    __hash_map_node_destructor(__hash_map_node_destructor const&) = default;
+    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&) = delete;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __hash_map_node_destructor(allocator_type& __na)
+        : __na_(__na),
+          __first_constructed(false),
+          __second_constructed(false)
+        {}
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_node_destructor(std::__hash_node_destructor<allocator_type>&& __x)
+        : __na_(__x.__na_),
+          __first_constructed(__x.__value_constructed),
+          __second_constructed(__x.__value_constructed)
+        {
+            __x.__value_constructed = false;
+        }
+#else  // _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_node_destructor(const std::__hash_node_destructor<allocator_type>& __x)
+        : __na_(__x.__na_),
+          __first_constructed(__x.__value_constructed),
+          __second_constructed(__x.__value_constructed)
+        {
+            const_cast<bool&>(__x.__value_constructed) = false;
+        }
+#endif  // _LIBCUDACXX_CXX03_LANG
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void operator()(pointer __p)
+    {
+        if (__second_constructed)
+            __alloc_traits::destroy(__na_, _CUDA_VSTD::addressof(__p->__value_.second));
+        if (__first_constructed)
+            __alloc_traits::destroy(__na_, _CUDA_VSTD::addressof(__p->__value_.first));
+        if (__p)
+            __alloc_traits::deallocate(__na_, __p, 1);
+    }
+};
+
+template <class _HashIterator>
+class _LIBCUDACXX_TEMPLATE_VIS __hash_map_iterator
+{
+    _HashIterator __i_;
+
+    typedef const typename _HashIterator::value_type::first_type key_type;
+    typedef typename _HashIterator::value_type::second_type      mapped_type;
+public:
+    typedef std::forward_iterator_tag                            iterator_category;
+    typedef std::pair<key_type, mapped_type>                     value_type;
+    typedef typename _HashIterator::difference_type              difference_type;
+    typedef value_type&                                          reference;
+    typedef typename std::__rebind_pointer<typename _HashIterator::pointer, value_type>::type
+        pointer;
+
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_iterator() {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY reference operator*() const {return *operator->();}
+    _LIBCUDACXX_INLINE_VISIBILITY pointer operator->() const {return (pointer)__i_.operator->();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_iterator& operator++() {++__i_; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_iterator operator++(int)
+    {
+        __hash_map_iterator __t(*this);
+        ++(*this);
+        return __t;
+    }
+
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
+        {return __x.__i_ == __y.__i_;}
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
+        {return __x.__i_ != __y.__i_;}
+
+    template <class, class, class, class, class> friend class _LIBCUDACXX_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCUDACXX_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCUDACXX_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCUDACXX_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCUDACXX_TEMPLATE_VIS __hash_map_const_iterator;
+};
+
+template <class _HashIterator>
+class _LIBCUDACXX_TEMPLATE_VIS __hash_map_const_iterator
+{
+    _HashIterator __i_;
+
+    typedef const typename _HashIterator::value_type::first_type key_type;
+    typedef typename _HashIterator::value_type::second_type      mapped_type;
+public:
+    typedef std::forward_iterator_tag                            iterator_category;
+    typedef std::pair<key_type, mapped_type>                     value_type;
+    typedef typename _HashIterator::difference_type              difference_type;
+    typedef const value_type&                                    reference;
+    typedef typename std::__rebind_pointer<typename _HashIterator::pointer, const value_type>::type
+        pointer;
+
+    _LIBCUDACXX_INLINE_VISIBILITY __hash_map_const_iterator() {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_const_iterator(
+            __hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
+                : __i_(__i.__i_) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    reference operator*() const {return *operator->();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    pointer operator->() const {return (pointer)__i_.operator->();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_const_iterator& operator++() {++__i_; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __hash_map_const_iterator operator++(int)
+    {
+        __hash_map_const_iterator __t(*this);
+        ++(*this);
+        return __t;
+    }
+
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
+        {return __x.__i_ == __y.__i_;}
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
+        {return __x.__i_ != __y.__i_;}
+
+    template <class, class, class, class, class> friend class _LIBCUDACXX_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCUDACXX_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCUDACXX_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCUDACXX_TEMPLATE_VIS __hash_const_local_iterator;
+};
+
+template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+class _LIBCUDACXX_TEMPLATE_VIS hash_map
+{
+public:
+    // types
+    typedef _Key                                           key_type;
+    typedef _Tp                                            mapped_type;
+    typedef _Tp                                            data_type;
+    typedef _Hash                                          hasher;
+    typedef _Pred                                          key_equal;
+    typedef _Alloc                                         allocator_type;
+    typedef std::pair<const key_type, mapped_type>         value_type;
+    typedef value_type&                                    reference;
+    typedef const value_type&                              const_reference;
+
+private:
+    typedef std::pair<key_type, mapped_type>                    __value_type;
+    typedef __hash_map_hasher<__value_type, hasher>   __hasher;
+    typedef __hash_map_equal<__value_type, key_equal> __key_equal;
+    typedef typename std::__rebind_alloc_helper<
+        std::allocator_traits<allocator_type>, __value_type>::type __allocator_type;
+
+    typedef std::__hash_table<__value_type, __hasher,
+                         __key_equal,  __allocator_type>   __table;
+
+    __table __table_;
+
+    typedef typename __table::__node_pointer               __node_pointer;
+    typedef typename __table::__node_const_pointer         __node_const_pointer;
+    typedef typename __table::__node_traits                __node_traits;
+    typedef typename __table::__node_allocator             __node_allocator;
+    typedef typename __table::__node                       __node;
+    typedef __hash_map_node_destructor<__node_allocator>   _Dp;
+    typedef std::unique_ptr<__node, _Dp>                   __node_holder;
+    typedef std::allocator_traits<allocator_type>          __alloc_traits;
+public:
+    typedef typename __alloc_traits::pointer         pointer;
+    typedef typename __alloc_traits::const_pointer   const_pointer;
+    typedef typename __alloc_traits::size_type       size_type;
+    typedef typename __alloc_traits::difference_type difference_type;
+
+    typedef __hash_map_iterator<typename __table::iterator>       iterator;
+    typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+
+    _LIBCUDACXX_INLINE_VISIBILITY hash_map() { }
+    explicit hash_map(size_type __n, const hasher& __hf = hasher(),
+                           const key_equal& __eql = key_equal());
+    hash_map(size_type __n, const hasher& __hf,
+                  const key_equal& __eql,
+                  const allocator_type& __a);
+    template <class _InputIterator>
+        hash_map(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
+        hash_map(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
+        hash_map(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf,
+                      const key_equal& __eql,
+                      const allocator_type& __a);
+    hash_map(const hash_map& __u);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool      empty() const {return __table_.size() == 0;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type size() const  {return __table_.size();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_size() const {return __table_.max_size();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       begin()        {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       end()          {return __table_.end();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator begin()  const {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator end()    const {return __table_.end();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, bool> insert(const value_type& __x)
+        {return __table_.__insert_unique(__x);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
+    template <class _InputIterator>
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __p) {__table_.erase(__p.__i_);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __first, const_iterator __last)
+        {__table_.erase(__first.__i_, __last.__i_);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void clear() {__table_.clear();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(hash_map& __u) {__table_.swap(__u.__table_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hasher hash_funct() const
+        {return __table_.hash_function().hash_function();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    key_equal key_eq() const
+        {return __table_.key_eq().key_eq();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_unique(__k);}
+
+    mapped_type& operator[](const key_type& __k);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type bucket_count() const {return __table_.bucket_count();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type elems_in_bucket(size_type __n) const
+        {return __table_.bucket_size(__n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void resize(size_type __n) {__table_.rehash(__n);}
+
+private:
+    __node_holder __construct_node(const key_type& __k);
+};
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        size_type __n, const hasher& __hf, const key_equal& __eql,
+        const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        _InputIterator __first, _InputIterator __last)
+{
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+        const hash_map& __u)
+    : __table_(__u.__table_)
+{
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
+{
+    __node_allocator& __na = __table_.__node_alloc();
+    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+    __node_traits::construct(__na, _CUDA_VSTD::addressof(__h->__value_.first), __k);
+    __h.get_deleter().__first_constructed = true;
+    __node_traits::construct(__na, _CUDA_VSTD::addressof(__h->__value_.second));
+    __h.get_deleter().__second_constructed = true;
+    return _LIBCUDACXX_EXPLICIT_MOVE(__h);  // explicitly moved for C++03
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                       _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_unique(*__first);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+_Tp&
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
+{
+    iterator __i = find(__k);
+    if (__i != end())
+        return __i->second;
+    __node_holder __h = __construct_node(__k);
+    std::pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
+    __h.release();
+    return __r.first->second;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+     hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    __x.swap(__y);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+           const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
+            __i != __ex; ++__i)
+    {
+        const_iterator __j = __y.find(__i->first);
+        if (__j == __ey || !(*__i == *__j))
+            return false;
+    }
+    return true;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+           const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+class _LIBCUDACXX_TEMPLATE_VIS hash_multimap
+{
+public:
+    // types
+    typedef _Key                                           key_type;
+    typedef _Tp                                            mapped_type;
+    typedef _Tp                                            data_type;
+    typedef _Hash                                          hasher;
+    typedef _Pred                                          key_equal;
+    typedef _Alloc                                         allocator_type;
+    typedef std::pair<const key_type, mapped_type>         value_type;
+    typedef value_type&                                    reference;
+    typedef const value_type&                              const_reference;
+
+private:
+    typedef std::pair<key_type, mapped_type>               __value_type;
+    typedef __hash_map_hasher<__value_type, hasher>   __hasher;
+    typedef __hash_map_equal<__value_type, key_equal> __key_equal;
+    typedef typename std::__rebind_alloc_helper<std::allocator_traits<allocator_type>, __value_type>::type __allocator_type;
+
+    typedef std::__hash_table<__value_type, __hasher,
+                         __key_equal,  __allocator_type>   __table;
+
+    __table __table_;
+
+    typedef typename __table::__node_traits                __node_traits;
+    typedef typename __table::__node_allocator             __node_allocator;
+    typedef typename __table::__node                       __node;
+    typedef __hash_map_node_destructor<__node_allocator>   _Dp;
+    typedef std::unique_ptr<__node, _Dp>                         __node_holder;
+    typedef std::allocator_traits<allocator_type>               __alloc_traits;
+public:
+    typedef typename __alloc_traits::pointer         pointer;
+    typedef typename __alloc_traits::const_pointer   const_pointer;
+    typedef typename __alloc_traits::size_type       size_type;
+    typedef typename __alloc_traits::difference_type difference_type;
+
+    typedef __hash_map_iterator<typename __table::iterator>       iterator;
+    typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hash_multimap() { }
+    explicit hash_multimap(size_type __n, const hasher& __hf = hasher(),
+                                const key_equal& __eql = key_equal());
+    hash_multimap(size_type __n, const hasher& __hf,
+                                const key_equal& __eql,
+                                const allocator_type& __a);
+    template <class _InputIterator>
+        hash_multimap(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
+        hash_multimap(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
+        hash_multimap(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf,
+                      const key_equal& __eql,
+                      const allocator_type& __a);
+    hash_multimap(const hash_multimap& __u);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool      empty() const {return __table_.size() == 0;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type size() const  {return __table_.size();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_size() const {return __table_.max_size();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       begin()        {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       end()          {return __table_.end();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator begin()  const {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator end()    const {return __table_.end();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
+    template <class _InputIterator>
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __p) {__table_.erase(__p.__i_);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __first, const_iterator __last)
+        {__table_.erase(__first.__i_, __last.__i_);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void clear() {__table_.clear();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(hash_multimap& __u) {__table_.swap(__u.__table_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hasher hash_funct() const
+        {return __table_.hash_function().hash_function();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    key_equal key_eq() const
+        {return __table_.key_eq().key_eq();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_multi(__k);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type bucket_count() const {return __table_.bucket_count();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type elems_in_bucket(size_type __n) const
+        {return __table_.bucket_size(__n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void resize(size_type __n) {__table_.rehash(__n);}
+};
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        size_type __n, const hasher& __hf, const key_equal& __eql,
+        const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        _InputIterator __first, _InputIterator __last)
+{
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+        const hash_multimap& __u)
+    : __table_(__u.__table_)
+{
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                            _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_multi(*__first);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+     hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    __x.swap(__y);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+           const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    typedef std::pair<const_iterator, const_iterator> _EqRng;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
+    {
+        _EqRng __xeq = __x.equal_range(__i->first);
+        _EqRng __yeq = __y.equal_range(__i->first);
+        if (_CUDA_VSTD::distance(__xeq.first, __xeq.second) !=
+            _CUDA_VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_CUDA_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+            return false;
+        __i = __xeq.second;
+    }
+    return true;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+           const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+} // __gnu_cxx
+
+#endif  // _LIBCUDACXX_HASH_MAP
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_set b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_set
new file mode 100644
index 0000000000000000000000000000000000000000..2b0594a80f7f56a8f275f6592c9a8e4f1cf13821
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/ext/hash_set
@@ -0,0 +1,659 @@
+// -*- C++ -*-
+//===------------------------- hash_set ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_HASH_SET
+#define _LIBCUDACXX_HASH_SET
+
+/*
+
+    hash_set synopsis
+
+namespace __gnu_cxx
+{
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class hash_set
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_set(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_set(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    hash_set(const hash_set&);
+    ~hash_set();
+    hash_set& operator=(const hash_set&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    pair<iterator, bool> insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_set&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(hash_set<Value, Hash, Pred, Alloc>& x,
+              hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_set<Value, Hash, Pred, Alloc>& x,
+               const hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_set<Value, Hash, Pred, Alloc>& x,
+               const hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class hash_multiset
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_multiset(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_multiset(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    hash_multiset(const hash_multiset&);
+    ~hash_multiset();
+    hash_multiset& operator=(const hash_multiset&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    iterator insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_multiset&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(hash_multiset<Value, Hash, Pred, Alloc>& x,
+              hash_multiset<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_multiset<Value, Hash, Pred, Alloc>& x,
+               const hash_multiset<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_multiset<Value, Hash, Pred, Alloc>& x,
+               const hash_multiset<Value, Hash, Pred, Alloc>& y);
+}  // __gnu_cxx
+
+*/
+
+#include <__config>
+#include <__hash_table>
+#include <functional>
+#include <ext/__hash>
+
+#if __DEPRECATED
+#if defined(_LIBCUDACXX_WARNING)
+    _LIBCUDACXX_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
+#else
+#   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
+#endif
+#endif
+
+namespace __gnu_cxx {
+
+
+template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+class _LIBCUDACXX_TEMPLATE_VIS hash_set
+{
+public:
+    // types
+    typedef _Value                                                     key_type;
+    typedef key_type                                                   value_type;
+    typedef _Hash                                                      hasher;
+    typedef _Pred                                                      key_equal;
+    typedef _Alloc                                                     allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+
+private:
+    typedef std::__hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+    __table __table_;
+
+public:
+    typedef typename __table::pointer         pointer;
+    typedef typename __table::const_pointer   const_pointer;
+    typedef typename __table::size_type       size_type;
+    typedef typename __table::difference_type difference_type;
+
+    typedef typename __table::const_iterator       iterator;
+    typedef typename __table::const_iterator       const_iterator;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hash_set() { }
+    explicit hash_set(size_type __n, const hasher& __hf = hasher(),
+                           const key_equal& __eql = key_equal());
+    hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+                  const allocator_type& __a);
+    template <class _InputIterator>
+        hash_set(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
+        hash_set(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
+        hash_set(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf, const key_equal& __eql,
+                      const allocator_type& __a);
+    hash_set(const hash_set& __u);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool      empty() const {return __table_.size() == 0;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type size() const  {return __table_.size();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_size() const {return __table_.max_size();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       begin()        {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       end()          {return __table_.end();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator begin()  const {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator end()    const {return __table_.end();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, bool> insert(const value_type& __x)
+        {return __table_.__insert_unique(__x);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
+    template <class _InputIterator>
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __p) {__table_.erase(__p);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __first, const_iterator __last)
+        {__table_.erase(__first, __last);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void clear() {__table_.clear();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(hash_set& __u) {__table_.swap(__u.__table_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hasher hash_funct() const {return __table_.hash_function();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    key_equal key_eq() const {return __table_.key_eq();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_unique(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_unique(__k);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type bucket_count() const {return __table_.bucket_count();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void resize(size_type __n) {__table_.rehash(__n);}
+};
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+        _InputIterator __first, _InputIterator __last)
+{
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+        const hash_set& __u)
+    : __table_(__u.__table_)
+{
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                    _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_unique(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
+     hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    __x.swap(__y);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
+           const hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename hash_set<_Value, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
+            __i != __ex; ++__i)
+    {
+        const_iterator __j = __y.find(*__i);
+        if (__j == __ey || !(*__i == *__j))
+            return false;
+    }
+    return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x,
+           const hash_set<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+class _LIBCUDACXX_TEMPLATE_VIS hash_multiset
+{
+public:
+    // types
+    typedef _Value                                                     key_type;
+    typedef key_type                                                   value_type;
+    typedef _Hash                                                      hasher;
+    typedef _Pred                                                      key_equal;
+    typedef _Alloc                                                     allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+
+private:
+    typedef std::__hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+    __table __table_;
+
+public:
+    typedef typename __table::pointer         pointer;
+    typedef typename __table::const_pointer   const_pointer;
+    typedef typename __table::size_type       size_type;
+    typedef typename __table::difference_type difference_type;
+
+    typedef typename __table::const_iterator       iterator;
+    typedef typename __table::const_iterator       const_iterator;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hash_multiset() { }
+    explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),
+                                const key_equal& __eql = key_equal());
+    hash_multiset(size_type __n, const hasher& __hf,
+                       const key_equal& __eql, const allocator_type& __a);
+    template <class _InputIterator>
+        hash_multiset(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
+        hash_multiset(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
+        hash_multiset(_InputIterator __first, _InputIterator __last,
+                      size_type __n , const hasher& __hf,
+                      const key_equal& __eql, const allocator_type& __a);
+    hash_multiset(const hash_multiset& __u);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool      empty() const {return __table_.size() == 0;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type size() const  {return __table_.size();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_size() const {return __table_.max_size();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       begin()        {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       end()          {return __table_.end();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator begin()  const {return __table_.begin();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator end()    const {return __table_.end();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
+    template <class _InputIterator>
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __p) {__table_.erase(__p);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void erase(const_iterator __first, const_iterator __last)
+        {__table_.erase(__first, __last);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void clear() {__table_.clear();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(hash_multiset& __u) {__table_.swap(__u.__table_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    hasher hash_funct() const {return __table_.hash_function();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    key_equal key_eq() const {return __table_.key_eq();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_multi(__k);}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_multi(__k);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type bucket_count() const {return __table_.bucket_count();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_type elems_in_bucket(size_type __n) const {return __table_.bucket_size(__n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void resize(size_type __n) {__table_.rehash(__n);}
+};
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        size_type __n, const hasher& __hf, const key_equal& __eql,
+        const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        _InputIterator __first, _InputIterator __last)
+{
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+        const hash_multiset& __u)
+    : __table_(__u.__table_)
+{
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                    _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_multi(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+     hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    __x.swap(__y);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+           const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename hash_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    typedef std::pair<const_iterator, const_iterator> _EqRng;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
+    {
+        _EqRng __xeq = __x.equal_range(*__i);
+        _EqRng __yeq = __y.equal_range(*__i);
+        if (_CUDA_VSTD::distance(__xeq.first, __xeq.second) !=
+            _CUDA_VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_CUDA_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+            return false;
+        __i = __xeq.second;
+    }
+    return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+           const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+} // __gnu_cxx
+
+#endif  // _LIBCUDACXX_HASH_SET
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/android/locale_bionic.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/android/locale_bionic.h
new file mode 100644
index 0000000000000000000000000000000000000000..88a399a77c698d595fa9c2da546b9328bee8cb30
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/android/locale_bionic.h
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//===------------------- support/android/locale_bionic.h ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_ANDROID_LOCALE_BIONIC_H
+#define _LIBCUDACXX_SUPPORT_ANDROID_LOCALE_BIONIC_H
+
+#if defined(__BIONIC__)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <xlocale.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(__ANDROID__)
+
+#include <android/api-level.h>
+#include <android/ndk-version.h>
+#include <support/xlocale/__posix_l_fallback.h>
+// In NDK versions later than 16, locale-aware functions are provided by
+// legacy_stdlib_inlines.h
+#if __NDK_MAJOR__ <= 16
+#if __ANDROID_API__ < 21
+#include <support/xlocale/__strtonum_fallback.h>
+#elif __ANDROID_API__ < 26
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+inline _LIBCUDACXX_INLINE_VISIBILITY float strtof_l(const char* __nptr, char** __endptr,
+                                                locale_t) {
+  return ::strtof(__nptr, __endptr);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY double strtod_l(const char* __nptr,
+                                                 char** __endptr, locale_t) {
+  return ::strtod(__nptr, __endptr);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY long strtol_l(const char* __nptr, char** __endptr,
+                                               int __base, locale_t) {
+  return ::strtol(__nptr, __endptr, __base);
+}
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // __ANDROID_API__ < 26
+
+#endif // __NDK_MAJOR__ <= 16
+#endif // defined(__ANDROID__)
+
+#endif // defined(__BIONIC__)
+#endif // _LIBCUDACXX_SUPPORT_ANDROID_LOCALE_BIONIC_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ac30222c0f1a8e0fa2e3d376f99389b5b15e3ca
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_base.h
@@ -0,0 +1,219 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_ATOMIC_BASE_H
+#define _LIBCUDACXX_ATOMIC_BASE_H
+
+#include "cxx_atomic.h"
+
+// Guard ifdef for lock free query in case it is assigned elsewhere (MSVC/CUDA)
+#ifndef _LIBCUDACXX_ATOMIC_IS_LOCK_FREE
+#define _LIBCUDACXX_ATOMIC_IS_LOCK_FREE(__x) __atomic_is_lock_free(__x, 0)
+#endif
+
+_LIBCUDACXX_INLINE_VISIBILITY inline _LIBCUDACXX_CONSTEXPR int __cxx_atomic_order_to_int(memory_order __order) {
+  // Avoid switch statement to make this a constexpr.
+  return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
+         (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
+          (__order == memory_order_release ? __ATOMIC_RELEASE:
+           (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
+            (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
+              __ATOMIC_CONSUME))));
+}
+
+_LIBCUDACXX_INLINE_VISIBILITY inline _LIBCUDACXX_CONSTEXPR int __cxx_atomic_failure_order_to_int(memory_order __order) {
+  // Avoid switch statement to make this a constexpr.
+  return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
+         (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
+          (__order == memory_order_release ? __ATOMIC_RELAXED:
+           (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
+            (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE:
+              __ATOMIC_CONSUME))));
+}
+
+template <typename _Tp, typename _Up>
+inline void __cxx_atomic_init(volatile _Tp* __a,  _Up __val) {
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  __cxx_atomic_assign_volatile(*__a_tmp, __val);
+}
+
+template <typename _Tp, typename _Up>
+inline void __cxx_atomic_init(_Tp* __a,  _Up __val) {
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  *__a_tmp = __val;
+}
+
+inline
+void __cxx_atomic_thread_fence(memory_order __order) {
+  __atomic_thread_fence(__cxx_atomic_order_to_int(__order));
+}
+
+inline
+void __cxx_atomic_signal_fence(memory_order __order) {
+  __atomic_signal_fence(__cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Up>
+inline void __cxx_atomic_store(_Tp* __a,  _Up __val,
+                        memory_order __order) {
+  auto __v_temp = __cxx_atomic_wrap_to_base(__a, __val);
+  __atomic_store(__cxx_atomic_unwrap(__a), &__v_temp, __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp>
+inline auto __cxx_atomic_load(const _Tp* __a,
+                       memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __ret = __cxx_atomic_base_temporary(__a);
+  __atomic_load(__cxx_atomic_unwrap(__a), &__ret, __cxx_atomic_order_to_int(__order));
+  return *__cxx_get_underlying_atomic(&__ret);
+}
+
+template <typename _Tp, typename _Up>
+inline auto __cxx_atomic_exchange(_Tp* __a, _Up __val,
+                          memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __v_temp = __cxx_atomic_wrap_to_base(__a, __val);
+  auto __ret = __cxx_atomic_base_temporary(__a);
+  __atomic_exchange(__cxx_atomic_unwrap(__a), &__v_temp, &__ret, __cxx_atomic_order_to_int(__order));
+  return *__cxx_get_underlying_atomic(&__ret);
+}
+
+template <typename _Tp, typename _Up>
+inline bool __cxx_atomic_compare_exchange_strong(
+    _Tp* __a, _Up* __expected, _Up __value, memory_order __success,
+    memory_order __failure) {
+  (void)__expected;
+  return __atomic_compare_exchange(__cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a)),
+                                   __expected, &__value, false,
+                                   __cxx_atomic_order_to_int(__success),
+                                   __cxx_atomic_failure_order_to_int(__failure));
+}
+
+template <typename _Tp, typename _Up>
+inline bool __cxx_atomic_compare_exchange_weak(
+    _Tp* __a, _Up* __expected, _Up __value, memory_order __success,
+    memory_order __failure) {
+  (void)__expected;
+  return __atomic_compare_exchange(__cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a)),
+                                   __expected, &__value, true,
+                                   __cxx_atomic_order_to_int(__success),
+                                   __cxx_atomic_failure_order_to_int(__failure));
+}
+
+template <typename _Tp>
+struct __atomic_ptr_inc { enum {value = 1}; };
+
+template <typename _Tp>
+struct __atomic_ptr_inc<_Tp*> { enum {value = sizeof(_Tp)}; };
+
+// FIXME: Haven't figured out what the spec says about using arrays with
+// atomic_fetch_add. Force a failure rather than creating bad behavior.
+template <typename _Tp>
+struct __atomic_ptr_inc<_Tp[]> { };
+template <typename _Tp, int n>
+struct __atomic_ptr_inc<_Tp[n]> { };
+
+template <typename _Tp, typename _Td, __enable_if_t<!is_floating_point<__cxx_atomic_underlying_t<_Tp>>::value, int> = 0>
+inline auto __cxx_atomic_fetch_add(_Tp* __a, _Td __delta,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  constexpr auto __skip_v = __atomic_ptr_inc<__cxx_atomic_underlying_t<_Tp>>::value;
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  return __atomic_fetch_add(__a_tmp, __delta * __skip_v,
+                            __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Td, __enable_if_t<is_floating_point<__cxx_atomic_underlying_t<_Tp>>::value, int> = 0>
+inline auto __cxx_atomic_fetch_add(_Tp* __a, _Td __delta,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __expected = __cxx_atomic_load(__a, memory_order_relaxed);
+  auto __desired = __expected + __delta;
+
+  while(!__cxx_atomic_compare_exchange_strong(__a, &__expected, __desired, __order, __order)) {
+      __desired = __expected + __delta;
+  }
+
+  return __expected;
+}
+
+template <typename _Tp, typename _Td, __enable_if_t<!is_floating_point<__cxx_atomic_underlying_t<_Tp>>::value, int> = 0>
+inline auto __cxx_atomic_fetch_sub(_Tp* __a, _Td __delta,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  constexpr auto __skip_v = __atomic_ptr_inc<__cxx_atomic_underlying_t<_Tp>>::value;
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  return __atomic_fetch_sub(__a_tmp, __delta * __skip_v,
+                            __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Td, __enable_if_t<is_floating_point<__cxx_atomic_underlying_t<_Tp>>::value, int> = 0>
+inline auto __cxx_atomic_fetch_sub(_Tp* __a, _Td __delta,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __expected = __cxx_atomic_load(__a, memory_order_relaxed);
+  auto __desired = __expected - __delta;
+
+  while(!__cxx_atomic_compare_exchange_strong(__a, &__expected, __desired, __order, __order)) {
+      __desired = __expected - __delta;
+  }
+
+  return __expected;
+}
+
+template <typename _Tp, typename _Td>
+inline auto __cxx_atomic_fetch_and(_Tp* __a, _Td __pattern,
+                            memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  return __atomic_fetch_and(__a_tmp, __pattern,
+                            __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Td>
+inline auto __cxx_atomic_fetch_or(_Tp* __a, _Td __pattern,
+                          memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  return __atomic_fetch_or(__a_tmp, __pattern,
+                           __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Td>
+inline auto __cxx_atomic_fetch_xor(_Tp* __a, _Td __pattern,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __a_tmp = __cxx_get_underlying_atomic(__cxx_atomic_unwrap(__a));
+  return __atomic_fetch_xor(__a_tmp, __pattern,
+                            __cxx_atomic_order_to_int(__order));
+}
+
+template <typename _Tp, typename _Td>
+inline auto __cxx_atomic_fetch_max(_Tp* __a, _Td __val,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __expected = __cxx_atomic_load(__a, memory_order_relaxed);
+  auto __desired = __expected > __val ? __expected : __val;
+
+  while(__desired == __val &&
+          !__cxx_atomic_compare_exchange_strong(__a, &__expected, __desired, __order, __order)) {
+      __desired = __expected > __val ? __expected : __val;
+  }
+
+  return __expected;
+}
+
+template <typename _Tp, typename _Td>
+inline auto __cxx_atomic_fetch_min(_Tp* __a, _Td __val,
+                           memory_order __order) -> __cxx_atomic_underlying_t<_Tp> {
+  auto __expected = __cxx_atomic_load(__a, memory_order_relaxed);
+  auto __desired = __expected < __val ? __expected : __val;
+
+  while(__desired == __val &&
+          !__cxx_atomic_compare_exchange_strong(__a, &__expected, __desired, __order, __order)) {
+      __desired = __expected < __val ? __expected : __val;
+  }
+
+  return __expected;
+}
+
+#endif // _LIBCUDACXX_ATOMIC_BASE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_c11.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_c11.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b21f9b95d57d3ec96dccc53f351cda423f21869
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_c11.h
@@ -0,0 +1,184 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// Atomics for C11
+
+template <typename _Tp>
+struct __cxx_atomic_base_impl {
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+#ifndef _LIBCUDACXX_CXX03_LANG
+    __cxx_atomic_base_impl() _NOEXCEPT = default;
+#else
+    __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
+#endif // _LIBCUDACXX_CXX03_LANG
+  _LIBCUDACXX_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
+    : __a_value(value) {}
+  _LIBCUDACXX_DISABLE_EXTENSION_WARNING _Atomic(_Tp) __a_value;
+};
+
+#ifndef _LIBCUDACXX_ATOMIC_IS_LOCK_FREE
+#define _LIBCUDACXX_ATOMIC_IS_LOCK_FREE(__x) __c11_atomic_is_lock_free(__x, 0)
+#endif
+
+_LIBCUDACXX_INLINE_VISIBILITY inline
+void __cxx_atomic_thread_fence(memory_order __order) _NOEXCEPT {
+    __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));
+}
+
+_LIBCUDACXX_INLINE_VISIBILITY inline
+void __cxx_atomic_signal_fence(memory_order __order) _NOEXCEPT {
+    __c11_atomic_signal_fence(static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val) _NOEXCEPT {
+    __c11_atomic_init(&__a->__a_value, __val);
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val) _NOEXCEPT {
+    __c11_atomic_init(&__a->__a_value, __val);
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) _NOEXCEPT {
+    __c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val, memory_order __order) _NOEXCEPT {
+    __c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) _NOEXCEPT {
+    using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*;
+    return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) _NOEXCEPT {
+    using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*;
+    return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> * __a, _Tp __value, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+    return __c11_atomic_compare_exchange_strong(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+    return __c11_atomic_compare_exchange_strong(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+    return __c11_atomic_compare_exchange_weak(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+    return __c11_atomic_compare_exchange_weak(&__a->__a_value, __expected, __value,  static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_and(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_and(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_or(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_or(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_xor(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
+template<class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+    return __c11_atomic_fetch_xor(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda.h
new file mode 100644
index 0000000000000000000000000000000000000000..82542f60598e77cf0425e4f29b73001c6cbce60e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda.h
@@ -0,0 +1,480 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__CUDA_MINIMUM_ARCH__) && ((!defined(_LIBCUDACXX_COMPILER_MSVC) && __CUDA_MINIMUM_ARCH__ < 600) || (defined(_LIBCUDACXX_COMPILER_MSVC) && __CUDA_MINIMUM_ARCH__ < 700))
+#  error "CUDA atomics are only supported for sm_60 and up on *nix and sm_70 and up on Windows."
+#endif
+
+inline _LIBCUDACXX_HOST_DEVICE int __stronger_order_cuda(int __a, int __b) {
+    int const __max = __a > __b ? __a : __b;
+    if(__max != __ATOMIC_RELEASE)
+        return __max;
+    static int const __xform[] = {
+        __ATOMIC_RELEASE,
+        __ATOMIC_ACQ_REL,
+        __ATOMIC_ACQ_REL,
+        __ATOMIC_RELEASE };
+    return __xform[__a < __b ? __a : __b];
+}
+
+// pre-define lock free query for heterogeneous compatibility
+#ifndef _LIBCUDACXX_ATOMIC_IS_LOCK_FREE
+#define _LIBCUDACXX_ATOMIC_IS_LOCK_FREE(__x) (__x <= 8)
+#endif
+
+// Wrap host atomic implementations into a sub-namespace
+namespace __host {
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  include "atomic_msvc.h"
+#elif defined (_LIBCUDACXX_HAS_GCC_ATOMIC_IMP)
+#  include "atomic_gcc.h"
+#elif defined (_LIBCUDACXX_HAS_C11_ATOMIC_IMP)
+//TODO
+// #  include "atomic_c11.h"
+#elif defined(_LIBCUDACXX_COMPILER_NVRTC)
+#  include "atomic_nvrtc.h"
+#endif
+}
+
+using __host::__cxx_atomic_underlying_t;
+
+#include "atomic_cuda_generated.h"
+#include "atomic_cuda_derived.h"
+
+_LIBCUDACXX_INLINE_VISIBILITY
+inline
+ void __cxx_atomic_thread_fence(memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            __atomic_thread_fence_cuda(static_cast<__memory_order_underlying_t>(__order), __thread_scope_system_tag());
+        ),
+        NV_IS_HOST, (
+            __host::__cxx_atomic_thread_fence(__order);
+        )
+    )
+}
+
+_LIBCUDACXX_INLINE_VISIBILITY
+inline
+ void __cxx_atomic_signal_fence(memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            __atomic_signal_fence_cuda(static_cast<__memory_order_underlying_t>(__order));
+        ),
+        NV_IS_HOST, (
+            __host::__cxx_atomic_signal_fence(__order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref = false>
+struct __cxx_atomic_base_heterogeneous_impl {
+    __cxx_atomic_base_heterogeneous_impl() noexcept = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR explicit
+      __cxx_atomic_base_heterogeneous_impl(_Tp __value) : __a_value(__value) {
+    }
+
+    using __underlying_t = _Tp;
+    static constexpr int __sco = _Sco;
+
+    __host::__cxx_atomic_base_impl<_Tp, _Sco> __a_value;
+};
+
+template <typename _Tp, int _Sco>
+struct __cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, true> {
+    __cxx_atomic_base_heterogeneous_impl() noexcept = default;
+
+    static_assert(sizeof(_Tp) >= 4, "atomic_ref does not support 1 or 2 byte types");
+    static_assert(sizeof(_Tp) <= 8, "atomic_ref does not support types larger than 8 bytes");
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR explicit
+      __cxx_atomic_base_heterogeneous_impl(_Tp& __value) : __a_value(__value) {
+    }
+
+    using __underlying_t = _Tp;
+    static constexpr int __sco = _Sco;
+
+    __host::__cxx_atomic_ref_base_impl<_Tp, _Sco> __a_value;
+};
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Tp* __cxx_get_underlying_device_atomic(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> * __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(&__a->__a_value);
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+volatile _Tp* __cxx_get_underlying_device_atomic(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(&__a->__a_value);
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const _Tp* __cxx_get_underlying_device_atomic(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> const* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(&__a->__a_value);
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const volatile _Tp* __cxx_get_underlying_device_atomic(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> const volatile* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(&__a->__a_value);
+}
+
+template <typename _Tp>
+using __cxx_atomic_small_to_32 = __conditional_t<is_signed<_Tp>::value, int32_t, uint32_t>;
+
+// Arithmetic conversions to/from proxy types
+template<class _Tp, __enable_if_t<is_arithmetic<_Tp>::value, int> = 0>
+_LIBCUDACXX_CONSTEXPR _LIBCUDACXX_INLINE_VISIBILITY inline __cxx_atomic_small_to_32<_Tp> __cxx_small_to_32(_Tp __val) {
+    return static_cast<__cxx_atomic_small_to_32<_Tp>>(__val);
+}
+
+template<class _Tp, __enable_if_t<is_arithmetic<_Tp>::value, int> = 0>
+_LIBCUDACXX_CONSTEXPR _LIBCUDACXX_INLINE_VISIBILITY inline _Tp __cxx_small_from_32(__cxx_atomic_small_to_32<_Tp> __val) {
+    return static_cast<_Tp>(__val);
+}
+
+// Non-arithmetic conversion to/from proxy types
+template<class _Tp, __enable_if_t<!is_arithmetic<_Tp>::value, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY inline __cxx_atomic_small_to_32<_Tp> __cxx_small_to_32(_Tp __val) {
+    __cxx_atomic_small_to_32<_Tp> __temp{};
+    memcpy(&__temp, &__val, sizeof(_Tp));
+    return __temp;
+}
+
+template<class _Tp, __enable_if_t<!is_arithmetic<_Tp>::value, int> = 0>
+_LIBCUDACXX_INLINE_VISIBILITY inline _Tp __cxx_small_from_32(__cxx_atomic_small_to_32<_Tp> __val) {
+    _Tp __temp{};
+    memcpy(&__temp, &__val, sizeof(_Tp));
+    return __temp;
+}
+
+template <typename _Tp, int _Sco>
+struct __cxx_atomic_base_small_impl {
+    __cxx_atomic_base_small_impl() noexcept = default;
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR explicit
+      __cxx_atomic_base_small_impl(_Tp __value) : __a_value(__cxx_small_to_32(__value)) {
+    }
+
+    using __underlying_t = _Tp;
+    static constexpr int __sco = _Sco;
+
+    __cxx_atomic_base_heterogeneous_impl<__cxx_atomic_small_to_32<_Tp>, _Sco, false> __a_value;
+};
+
+template <typename _Tp, int _Sco>
+using __cxx_atomic_base_impl = __conditional_t<sizeof(_Tp) < 4,
+                                    __cxx_atomic_base_small_impl<_Tp, _Sco>,
+                                    __cxx_atomic_base_heterogeneous_impl<_Tp, _Sco> >;
+
+
+template <typename _Tp, int _Sco>
+using __cxx_atomic_ref_base_impl = __cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, true>;
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ void __cxx_atomic_init(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __val) {
+    alignas(_Tp) auto __tmp = __val;
+    __cxx_atomic_assign_volatile(*__cxx_get_underlying_device_atomic(__a), __tmp);
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ void __cxx_atomic_store(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __val, memory_order __order) {
+    alignas(_Tp) auto __tmp = __val;
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            __atomic_store_n_cuda(__cxx_get_underlying_device_atomic(__a), __tmp, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            __host::__cxx_atomic_store(&__a->__a_value, __tmp, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_load(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> const volatile* __a, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_load_n_cuda(__cxx_get_underlying_device_atomic(__a), static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_load(&__a->__a_value, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_exchange(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __val, memory_order __order) {
+    alignas(_Tp) auto __tmp = __val;
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_exchange_n_cuda(__cxx_get_underlying_device_atomic(__a), __tmp, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_exchange(&__a->__a_value, __tmp, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp* __expected, _Tp __val, memory_order __success, memory_order __failure) {
+    alignas(_Tp) auto __tmp = *__expected;
+    bool __result = false;
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            alignas(_Tp) auto __tmp_v = __val;
+            __result = __atomic_compare_exchange_cuda(__cxx_get_underlying_device_atomic(__a), &__tmp, &__tmp_v, false, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            __result = __host::__cxx_atomic_compare_exchange_strong(&__a->__a_value, &__tmp, __val, __success, __failure);
+        )
+    )
+    *__expected = __tmp;
+    return __result;
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp* __expected, _Tp __val, memory_order __success, memory_order __failure) {
+    alignas(_Tp) auto __tmp = *__expected;
+    bool __result = false;
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            alignas(_Tp) auto __tmp_v = __val;
+            __result = __atomic_compare_exchange_cuda(__cxx_get_underlying_device_atomic(__a), &__tmp, &__tmp_v, true, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            __result = __host::__cxx_atomic_compare_exchange_weak(&__a->__a_value, &__tmp, __val, __success, __failure);
+        )
+    )
+    *__expected = __tmp;
+    return __result;
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_add(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __delta, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_add_cuda(__cxx_get_underlying_device_atomic(__a), __delta, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_add(&__a->__a_value, __delta, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_heterogeneous_impl<_Tp*, _Sco, _Ref> volatile* __a, ptrdiff_t __delta, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_add_cuda(__cxx_get_underlying_device_atomic(__a), __delta, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_add(&__a->__a_value, __delta, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __delta, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_sub_cuda(__cxx_get_underlying_device_atomic(__a), __delta, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_sub(&__a->__a_value, __delta, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_heterogeneous_impl<_Tp*, _Sco, _Ref> volatile* __a, ptrdiff_t __delta, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_sub_cuda(__cxx_get_underlying_device_atomic(__a), __delta, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_sub(&__a->__a_value, __delta, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_and(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __pattern, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_and_cuda(__cxx_get_underlying_device_atomic(__a), __pattern, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_and(&__a->__a_value, __pattern, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_or(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __pattern, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_or_cuda(__cxx_get_underlying_device_atomic(__a), __pattern, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_or(&__a->__a_value, __pattern, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Tp __pattern, memory_order __order) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_xor_cuda(__cxx_get_underlying_device_atomic(__a), __pattern, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ),
+        NV_IS_HOST, (
+            return __host::__cxx_atomic_fetch_xor(&__a->__a_value, __pattern, __order);
+        )
+    )
+}
+
+template <typename _Tp, typename _Delta, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_max(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Delta __val, memory_order __order) {
+    NV_IF_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_max_cuda(__cxx_get_underlying_device_atomic(__a), __val, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ), (
+            return __host::__cxx_atomic_fetch_max(&__a->__a_value, __val, __order);
+        )
+    )
+}
+
+template <typename _Tp, typename _Delta, int _Sco, bool _Ref>
+_LIBCUDACXX_HOST_DEVICE
+ _Tp __cxx_atomic_fetch_min(__cxx_atomic_base_heterogeneous_impl<_Tp, _Sco, _Ref> volatile* __a, _Delta __val, memory_order __order) {
+    NV_IF_TARGET(
+        NV_IS_DEVICE, (
+            return __atomic_fetch_min_cuda(__cxx_get_underlying_device_atomic(__a), __val, static_cast<__memory_order_underlying_t>(__order), __scope_tag<_Sco>());
+        ), (
+            return __host::__cxx_atomic_fetch_min(&__a->__a_value, __val, __order);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline void __cxx_atomic_init(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __val) {
+    __cxx_atomic_init(&__a->__a_value, __cxx_small_to_32(__val));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline void __cxx_atomic_store(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __val, memory_order __order) {
+    __cxx_atomic_store(&__a->__a_value, __cxx_small_to_32(__val), __order);
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_load(__cxx_atomic_base_small_impl<_Tp, _Sco> const volatile* __a, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_load(&__a->__a_value, __order));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_exchange(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __value, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_exchange(&__a->__a_value, __cxx_small_to_32(__value), __order));
+}
+_LIBCUDACXX_HOST_DEVICE
+inline int __cuda_memcmp(void const * __lhs, void const * __rhs, size_t __count) {
+    NV_DISPATCH_TARGET(
+        NV_IS_DEVICE, (
+            auto __lhs_c = reinterpret_cast<unsigned char const *>(__lhs);
+            auto __rhs_c = reinterpret_cast<unsigned char const *>(__rhs);
+            while (__count--) {
+                auto const __lhs_v = *__lhs_c++;
+                auto const __rhs_v = *__rhs_c++;
+                if (__lhs_v < __rhs_v) { return -1; }
+                if (__lhs_v > __rhs_v) { return 1; }
+            }
+            return 0;
+        ),
+        NV_IS_HOST, (
+            return memcmp(__lhs, __rhs, __count);
+        )
+    )
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
+    auto __temp = __cxx_small_to_32(*__expected);
+    auto const __ret = __cxx_atomic_compare_exchange_weak(&__a->__a_value, &__temp, __cxx_small_to_32(__value), __success, __failure);
+    auto const __actual = __cxx_small_from_32<_Tp>(__temp);
+    constexpr auto __mask = static_cast<decltype(__temp)>((1u << (8*sizeof(_Tp))) - 1);
+    if(!__ret) {
+        if(0 == __cuda_memcmp(&__actual, __expected, sizeof(_Tp)))
+            __cxx_atomic_fetch_and(&__a->__a_value, __mask, memory_order_relaxed);
+        else
+            *__expected = __actual;
+    }
+    return __ret;
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
+    auto const __old = *__expected;
+    while(1) {
+        if(__cxx_atomic_compare_exchange_weak(__a, __expected, __value, __success, __failure))
+            return true;
+        if(0 != __cuda_memcmp(&__old, __expected, sizeof(_Tp)))
+            return false;
+    }
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_add(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __delta, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_add(&__a->__a_value, __cxx_small_to_32(__delta), __order));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __delta, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_sub(&__a->__a_value, __cxx_small_to_32(__delta), __order));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_and(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __pattern, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_and(&__a->__a_value, __cxx_small_to_32(__pattern), __order));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_or(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __pattern, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_or(&__a->__a_value, __cxx_small_to_32(__pattern), __order));
+}
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Tp __pattern, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_xor(&__a->__a_value, __cxx_small_to_32(__pattern), __order));
+}
+
+template <typename _Tp, typename _Delta, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_max(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Delta __val, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_max(&__a->__a_value, __cxx_small_to_32(__val), __order));
+}
+
+template <typename _Tp, typename _Delta, int _Sco>
+_LIBCUDACXX_HOST_DEVICE inline _Tp __cxx_atomic_fetch_min(__cxx_atomic_base_small_impl<_Tp, _Sco> volatile* __a, _Delta __val, memory_order __order) {
+    return __cxx_small_from_32<_Tp>(__cxx_atomic_fetch_min(&__a->__a_value, __cxx_small_to_32(__val), __order));
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_derived.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_derived.h
new file mode 100644
index 0000000000000000000000000000000000000000..e513dff6ece1503c0b5cea9048234bc5ca7488a6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_derived.h
@@ -0,0 +1,144 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+template<class _Type, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type) <= 2, int>::type = 0>
+bool _LIBCUDACXX_DEVICE __atomic_compare_exchange_cuda(_Type volatile *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, _Scope __s) {
+
+    auto const __aligned = (uint32_t*)((intptr_t)__ptr & ~(sizeof(uint32_t) - 1));
+    auto const __offset = uint32_t((intptr_t)__ptr & (sizeof(uint32_t) - 1)) * 8;
+    auto const __mask = ((1 << sizeof(_Type)*8) - 1) << __offset;
+
+    uint32_t __old = *__expected << __offset;
+    uint32_t __old_value;
+    while (1) {
+        __old_value = (__old & __mask) >> __offset;
+        if (__old_value != *__expected)
+            break;
+        uint32_t const __attempt = (__old & ~__mask) | (*__desired << __offset);
+        if (__atomic_compare_exchange_cuda(__aligned, &__old, &__attempt, true, __success_memorder, __failure_memorder, __s))
+            return true;
+    }
+    *__expected = __old_value;
+    return false;
+}
+
+template<class _Type, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+void _LIBCUDACXX_DEVICE __atomic_exchange_cuda(_Type volatile *__ptr, _Type *__val, _Type *__ret, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, __val, true, __memorder, __memorder, __s))
+        ;
+    *__ret = __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+_Type _LIBCUDACXX_DEVICE __atomic_fetch_add_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected + __val;
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s))
+        __desired = __expected + __val;
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2 || _CUDA_VSTD::is_floating_point<_Type>::value, int>::type = 0>
+_Type _LIBCUDACXX_HOST_DEVICE __atomic_fetch_max_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected > __val ? __expected : __val;
+
+    while(__desired == __val &&
+            !__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s)) {
+        __desired = __expected > __val ? __expected : __val;
+    }
+
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2 || _CUDA_VSTD::is_floating_point<_Type>::value, int>::type = 0>
+_Type _LIBCUDACXX_HOST_DEVICE __atomic_fetch_min_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected < __val ? __expected : __val;
+
+    while(__desired == __val &&
+            !__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s)) {
+        __desired = __expected < __val ? __expected : __val;
+    }
+
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+_Type _LIBCUDACXX_DEVICE __atomic_fetch_sub_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected - __val;
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s))
+        __desired = __expected - __val;
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+_Type _LIBCUDACXX_DEVICE __atomic_fetch_and_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected & __val;
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s))
+        __desired = __expected & __val;
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+_Type _LIBCUDACXX_DEVICE __atomic_fetch_xor_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected ^ __val;
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s))
+        __desired = __expected ^ __val;
+    return __expected;
+}
+
+template<class _Type, class _Delta, class _Scope, typename _CUDA_VSTD::enable_if<sizeof(_Type)<=2, int>::type = 0>
+_Type _LIBCUDACXX_DEVICE __atomic_fetch_or_cuda(_Type volatile *__ptr, _Delta __val, int __memorder, _Scope __s) {
+
+    _Type __expected = __atomic_load_n_cuda(__ptr, __ATOMIC_RELAXED, __s);
+    _Type __desired = __expected | __val;
+    while(!__atomic_compare_exchange_cuda(__ptr, &__expected, &__desired, true, __memorder, __memorder, __s))
+        __desired = __expected | __val;
+    return __expected;
+}
+
+template<class _Type, class _Scope>
+_Type _LIBCUDACXX_DEVICE __atomic_load_n_cuda(const _Type volatile *__ptr, int __memorder, _Scope __s) {
+    _Type __ret;
+    __atomic_load_cuda(__ptr, &__ret, __memorder, __s);
+    return __ret;
+}
+
+template<class _Type, class _Scope>
+void _LIBCUDACXX_DEVICE __atomic_store_n_cuda(_Type volatile *__ptr, _Type __val, int __memorder, _Scope __s) {
+    __atomic_store_cuda(__ptr, &__val, __memorder, __s);
+}
+
+template<class _Type, class _Scope>
+bool _LIBCUDACXX_DEVICE __atomic_compare_exchange_n_cuda(_Type volatile *__ptr, _Type *__expected, _Type __desired, bool __weak, int __success_memorder, int __failure_memorder, _Scope __s) {
+    return __atomic_compare_exchange_cuda(__ptr, __expected, &__desired, __weak, __success_memorder, __failure_memorder, __s);
+}
+
+template<class _Type, class _Scope>
+_Type _LIBCUDACXX_DEVICE __atomic_exchange_n_cuda(_Type volatile *__ptr, _Type __val, int __memorder, _Scope __s) {
+    _Type __ret;
+    __atomic_exchange_cuda(__ptr, &__val, &__ret, __memorder, __s);
+    return __ret;
+}
+
+static inline _LIBCUDACXX_DEVICE void __atomic_signal_fence_cuda(int) {
+    asm volatile("":::"memory");
+}
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_generated.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ff8f09238080c4df37e8ea7ba091b1bbbfd77b3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_cuda_generated.h
@@ -0,0 +1,3563 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+
+static inline _LIBCUDACXX_DEVICE void __cuda_membar_block() { asm volatile("membar.cta;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_acq_rel_block() { asm volatile("fence.acq_rel.cta;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_sc_block() { asm volatile("fence.sc.cta;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __atomic_thread_fence_cuda(int __memorder, __thread_scope_block_tag) {
+  NV_DISPATCH_TARGET(
+    NV_PROVIDES_SM_70, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST: __cuda_fence_sc_block(); break;
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_fence_acq_rel_block(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    ),
+    NV_IS_DEVICE, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST:
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_membar_block(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    )
+  )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.cta.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.cta.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_block_tag) {
+    uint32_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_32_block(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_32_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_32_block(__ptr, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_32_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.cta.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.cta.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_block_tag) {
+    uint64_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_64_block(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_64_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_64_block(__ptr, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_64_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_32_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.cta.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_32_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.cta.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_32_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_block_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_32_block(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_32_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_block();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_32_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_64_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.cta.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_64_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.cta.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_64_block(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_block_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_64_block(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_64_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_block();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_64_block(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.cta.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.cta.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.cta.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.cta.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.cta.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_block_tag) {
+    uint32_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 4);
+    memcpy(&__old, __expected, 4);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_32_block(__ptr, __old, __old_tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_compare_exchange_volatile_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_32_block(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_block_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_exchange_volatile_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_and_volatile_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_or_volatile_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.cta.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_xor_volatile_32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_max_volatile_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_max_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.cta.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_min_volatile_s32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_min_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.cta.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_sub_volatile_f32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u32_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.cta.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u32_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_sub_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u32_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.cta.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.cta.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.cta.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.cta.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.cta.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_block_tag) {
+    uint64_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 8);
+    memcpy(&__old, __expected, 8);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_64_block(__ptr, __old, __old_tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_compare_exchange_volatile_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_64_block(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_block_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_exchange_volatile_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_and_volatile_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_or_volatile_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.cta.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_xor_volatile_64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_max_volatile_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_max_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.cta.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_min_volatile_s64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_min_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.cta.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_sub_volatile_f64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u64_block(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.cta.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_block_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_sub_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_add_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_block_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_sub_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_block_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp = -__tmp;
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_block(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_block();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); __cuda_membar_block(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_block(); __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_block(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+static inline _LIBCUDACXX_DEVICE void __cuda_membar_device() { asm volatile("membar.gl;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_acq_rel_device() { asm volatile("fence.acq_rel.gpu;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_sc_device() { asm volatile("fence.sc.gpu;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __atomic_thread_fence_cuda(int __memorder, __thread_scope_device_tag) {
+  NV_DISPATCH_TARGET(
+    NV_PROVIDES_SM_70, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST: __cuda_fence_sc_device(); break;
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_fence_acq_rel_device(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    ),
+    NV_IS_DEVICE, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST:
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_membar_device(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    )
+  )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.gpu.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.gpu.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_device_tag) {
+    uint32_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_32_device(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_32_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_32_device(__ptr, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_32_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.gpu.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.gpu.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_device_tag) {
+    uint64_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_64_device(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_64_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_64_device(__ptr, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_64_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_32_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.gpu.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_32_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.gpu.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_32_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_device_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_32_device(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_32_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_device();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_32_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_64_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.gpu.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_64_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.gpu.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_64_device(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_device_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_64_device(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_64_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_device();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_64_device(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.gpu.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.gpu.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.gpu.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.gpu.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.gpu.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_device_tag) {
+    uint32_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 4);
+    memcpy(&__old, __expected, 4);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_32_device(__ptr, __old, __old_tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_compare_exchange_volatile_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_32_device(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_device_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_exchange_volatile_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_and_volatile_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_or_volatile_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.gpu.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_xor_volatile_32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_max_volatile_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_max_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.gpu.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_min_volatile_s32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_min_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.gpu.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_sub_volatile_f32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u32_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.gpu.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u32_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_sub_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u32_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.gpu.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.gpu.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.gpu.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.gpu.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.gpu.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_device_tag) {
+    uint64_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 8);
+    memcpy(&__old, __expected, 8);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_64_device(__ptr, __old, __old_tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_compare_exchange_volatile_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_64_device(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_device_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_exchange_volatile_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_and_volatile_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_or_volatile_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.gpu.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_xor_volatile_64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_max_volatile_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_max_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.gpu.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_min_volatile_s64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_min_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.gpu.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_sub_volatile_f64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u64_device(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.gpu.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_device_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_sub_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_add_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_device_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_sub_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_device_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp = -__tmp;
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_device(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_device();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); __cuda_membar_device(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_device(); __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_device(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+static inline _LIBCUDACXX_DEVICE void __cuda_membar_system() { asm volatile("membar.sys;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_acq_rel_system() { asm volatile("fence.acq_rel.sys;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __cuda_fence_sc_system() { asm volatile("fence.sc.sys;":::"memory"); }
+static inline _LIBCUDACXX_DEVICE void __atomic_thread_fence_cuda(int __memorder, __thread_scope_system_tag) {
+  NV_DISPATCH_TARGET(
+    NV_PROVIDES_SM_70, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST: __cuda_fence_sc_system(); break;
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_fence_acq_rel_system(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    ),
+    NV_IS_DEVICE, (
+      switch (__memorder) {
+        case __ATOMIC_SEQ_CST:
+        case __ATOMIC_CONSUME:
+        case __ATOMIC_ACQUIRE:
+        case __ATOMIC_ACQ_REL:
+        case __ATOMIC_RELEASE: __cuda_membar_system(); break;
+        case __ATOMIC_RELAXED: break;
+        default: assert(0);
+      }
+    )
+  )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.sys.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.sys.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b32 %0,[%1];" : "=r"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_system_tag) {
+    uint32_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_32_system(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_32_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_32_system(__ptr, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_32_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.acquire.sys.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.relaxed.sys.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_load_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst) {asm volatile("ld.volatile.b64 %0,[%1];" : "=l"(__dst) : "l"(__ptr) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_load_cuda(const volatile _Type *__ptr, _Type *__ret, int __memorder, __thread_scope_system_tag) {
+    uint64_t __tmp = 0;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_acquire_64_system(__ptr, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_load_relaxed_64_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_load_volatile_64_system(__ptr, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELAXED: __cuda_load_volatile_64_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_32_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.sys.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_32_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.sys.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_32_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b32 [%0], %1;" :: "l"(__ptr),"r"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_system_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_32_system(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_32_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_system();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_32_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_relaxed_64_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.relaxed.sys.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_release_64_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.release.sys.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _CUDA_A, class _CUDA_B> static inline _LIBCUDACXX_DEVICE void __cuda_store_volatile_64_system(_CUDA_A __ptr, _CUDA_B __src) { asm volatile("st.volatile.b64 [%0], %1;" :: "l"(__ptr),"l"(__src) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_store_cuda(volatile _Type *__ptr, _Type *__val, int __memorder, __thread_scope_system_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE: __cuda_store_release_64_system(__ptr, __tmp); break;
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_RELAXED: __cuda_store_relaxed_64_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_RELEASE:
+          case __ATOMIC_SEQ_CST: __cuda_membar_system();
+          case __ATOMIC_RELAXED: __cuda_store_volatile_64_system(__ptr, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.sys.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.sys.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.sys.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.sys.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.sys.b32 %0,[%1],%2,%3;" : "=r"(__dst) : "l"(__ptr),"r"(__cmp),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_system_tag) {
+    uint32_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 4);
+    memcpy(&__old, __expected, 4);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_32_system(__ptr, __old, __old_tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_compare_exchange_volatile_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_32_system(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_system_tag) {
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, __val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_exchange_volatile_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 4);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_and_volatile_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_or_volatile_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.sys.b32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_xor_volatile_32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_max_volatile_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_max_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.sys.s32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_min_volatile_s32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_min_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.sys.f32 %0,[%1],%2;" : "=f"(__dst) : "l"(__ptr),"f"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    float __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_sub_volatile_f32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u32_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.sys.u32 %0,[%1],%2;" : "=r"(__dst) : "l"(__ptr),"r"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==4 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint32_t __tmp = 0;
+    memcpy(&__tmp, &__val, 4);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u32_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_sub_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u32_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 4);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acq_rel_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acq_rel.sys.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.acquire.sys.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.relaxed.sys.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_release_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.release.sys.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C, class _CUDA_D> static inline _LIBCUDACXX_DEVICE void __cuda_compare_exchange_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __cmp, _CUDA_D __op) { asm volatile("atom.cas.sys.b64 %0,[%1],%2,%3;" : "=l"(__dst) : "l"(__ptr),"l"(__cmp),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE bool __atomic_compare_exchange_cuda(volatile _Type *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder, __thread_scope_system_tag) {
+    uint64_t __tmp = 0, __old = 0, __old_tmp;
+    memcpy(&__tmp, __desired, 8);
+    memcpy(&__old, __expected, 8);
+    __old_tmp = __old;
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_acquire_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_compare_exchange_acq_rel_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_compare_exchange_release_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_relaxed_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__stronger_order_cuda(__success_memorder, __failure_memorder)) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_compare_exchange_volatile_64_system(__ptr, __old, __old_tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_compare_exchange_volatile_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_compare_exchange_volatile_64_system(__ptr, __old, __old_tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    bool const __ret = __old == __old_tmp;
+    memcpy(__expected, &__old, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acq_rel_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acq_rel.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.acquire.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.relaxed.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_release_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.release.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_exchange_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.exch.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE void __atomic_exchange_cuda(volatile _Type *__ptr, _Type *__val, _Type *__ret, int __memorder, __thread_scope_system_tag) {
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, __val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_acquire_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_exchange_acq_rel_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_exchange_release_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_relaxed_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_exchange_volatile_64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_exchange_volatile_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_exchange_volatile_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(__ret, &__tmp, 8);
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acq_rel_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acq_rel.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.acquire.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.relaxed.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_release_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.release.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_and_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.and.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_and_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_acquire_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_and_acq_rel_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_and_release_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_relaxed_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_and_volatile_64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_and_volatile_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_and_volatile_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acq_rel_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acq_rel.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.acquire.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.relaxed.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_release_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.release.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_or_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.or.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_or_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_acquire_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_or_acq_rel_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_or_release_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_relaxed_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_or_volatile_64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_or_volatile_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_or_volatile_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acq_rel_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acq_rel.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_acquire_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.acquire.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_relaxed_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.relaxed.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_release_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.release.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_xor_volatile_64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.xor.sys.b64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_xor_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_acquire_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_xor_acq_rel_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_xor_release_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_relaxed_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_xor_volatile_64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_xor_volatile_64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_xor_volatile_64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_f64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_f64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_f64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acq_rel_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acq_rel.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_acquire_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.acquire.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_relaxed_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.relaxed.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_release_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.release.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_add_volatile_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.add.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_add_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_s64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_s64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_max_volatile_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_s64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acq_rel_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acq_rel.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_acquire_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.acquire.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_relaxed_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.relaxed.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_release_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.release.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_max_volatile_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.max.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_max_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_max_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_max_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_max_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_max_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_max_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_s64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.sys.s64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_signed<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_s64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_s64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_min_volatile_s64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_s64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acq_rel_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acq_rel.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_acquire_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.acquire.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_relaxed_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.relaxed.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_release_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.release.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_min_volatile_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { asm volatile("atom.min.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value && _CUDA_VSTD::is_unsigned<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_min_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_min_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_min_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_min_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_min_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_min_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_f64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.sys.f64 %0,[%1],%2;" : "=d"(__dst) : "l"(__ptr),"d"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_floating_point<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    double __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_f64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_f64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_sub_volatile_f64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_f64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acq_rel_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acq_rel.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_acquire_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.acquire.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_relaxed_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.relaxed.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_release_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.release.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _CUDA_A, class _CUDA_B, class _CUDA_C> static inline _LIBCUDACXX_DEVICE void __cuda_fetch_sub_volatile_u64_system(_CUDA_A __ptr, _CUDA_B& __dst, _CUDA_C __op) { __op = -__op;
+asm volatile("atom.add.sys.u64 %0,[%1],%2;" : "=l"(__dst) : "l"(__ptr),"l"(__op) : "memory"); }
+template<class _Type, _CUDA_VSTD::__enable_if_t<sizeof(_Type)==8 && _CUDA_VSTD::is_integral<_Type>::value, int> = 0>
+_LIBCUDACXX_DEVICE _Type __atomic_fetch_sub_cuda(volatile _Type *__ptr, _Type __val, int __memorder, __thread_scope_system_tag) {
+    _Type __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_sub_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_sub_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_sub_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_sub_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_sub_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_add_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_system_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
+template<class _Type>
+_LIBCUDACXX_DEVICE _Type* __atomic_fetch_sub_cuda(_Type *volatile *__ptr, ptrdiff_t __val, int __memorder, __thread_scope_system_tag) {
+    _Type* __ret;
+    uint64_t __tmp = 0;
+    memcpy(&__tmp, &__val, 8);
+    __tmp = -__tmp;
+    __tmp *= sizeof(_Type);
+    NV_DISPATCH_TARGET(
+      NV_PROVIDES_SM_70, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST: __cuda_fence_sc_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_acquire_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_ACQ_REL: __cuda_fetch_add_acq_rel_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELEASE: __cuda_fetch_add_release_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_relaxed_u64_system(__ptr, __tmp, __tmp); break;
+        }
+      ),
+      NV_IS_DEVICE, (
+        switch (__memorder) {
+          case __ATOMIC_SEQ_CST:
+          case __ATOMIC_ACQ_REL: __cuda_membar_system();
+          case __ATOMIC_CONSUME:
+          case __ATOMIC_ACQUIRE: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); __cuda_membar_system(); break;
+          case __ATOMIC_RELEASE: __cuda_membar_system(); __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          case __ATOMIC_RELAXED: __cuda_fetch_add_volatile_u64_system(__ptr, __tmp, __tmp); break;
+          default: assert(0);
+        }
+      )
+    )
+    memcpy(&__ret, &__tmp, 8);
+    return __ret;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_gcc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c1e883ea58b0fecf83844ffb2844e2df78cfc63
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_gcc.h
@@ -0,0 +1,17 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_ATOMIC_GCC_H
+#define _LIBCUDACXX_ATOMIC_GCC_H
+
+#include "atomic_base.h"
+
+#endif // _LIBCUDACXX_ATOMIC_GCC_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_msvc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_msvc.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ec509040e7362e4b2c229fec26be4d3e5291a16
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_msvc.h
@@ -0,0 +1,450 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _MSC_VER
+#error "This file is only for CL.EXE's benefit"
+#endif
+
+#define _LIBCUDACXX_COMPILER_BARRIER() _ReadWriteBarrier()
+
+#if defined(_M_ARM) || defined(_M_ARM64)
+    #define _LIBCUDACXX_MEMORY_BARRIER()             __dmb(0xB) // inner shared data memory barrier
+    #define _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER() _LIBCUDACXX_MEMORY_BARRIER()
+#elif defined(_M_IX86) || defined(_M_X64)
+    #define _LIBCUDACXX_MEMORY_BARRIER()             __faststorefence()
+    // x86/x64 hardware only emits memory barriers inside _Interlocked intrinsics
+    #define _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER() _LIBCUDACXX_COMPILER_BARRIER()
+#else // ^^^ x86/x64 / unsupported hardware vvv
+    #error Unsupported hardware
+#endif // hardware
+
+// MSVC Does not have compiler intrinsics for lock-free checking
+#ifndef _LIBCUDACXX_ATOMIC_IS_LOCK_FREE
+#define _LIBCUDACXX_ATOMIC_IS_LOCK_FREE(__x) (__x <= 8)
+#endif
+
+inline int __stronger_order_msvc(int __a, int __b) {
+    int const __max = __a > __b ? __a : __b;
+    if(__max != __ATOMIC_RELEASE)
+        return __max;
+    static int const __xform[] = {
+        __ATOMIC_RELEASE,
+        __ATOMIC_ACQ_REL,
+        __ATOMIC_ACQ_REL,
+        __ATOMIC_RELEASE };
+    return __xform[__a < __b ? __a : __b];
+}
+
+static inline void __atomic_signal_fence(int __memorder) {
+    if (__memorder != __ATOMIC_RELAXED)
+        _LIBCUDACXX_COMPILER_BARRIER();
+}
+
+static inline void __atomic_thread_fence(int __memorder) {
+    if (__memorder != __ATOMIC_RELAXED)
+        _LIBCUDACXX_MEMORY_BARRIER();
+}
+
+template <typename _Type, size_t _Size>
+using _enable_if_sized_as = typename enable_if<sizeof(_Type) == _Size, int>::type;
+
+template<class _Type, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_load_relaxed(const volatile _Type *__ptr, _Type *__ret) {
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    __int8 __tmp = *(const volatile __int8 *)__ptr;
+#else
+    __int8 __tmp = __iso_volatile_load8((const volatile __int8 *)__ptr);
+#endif
+    *__ret = reinterpret_cast<_Type&>(__tmp);
+}
+template<class _Type, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_load_relaxed(const volatile _Type *__ptr, _Type *__ret) {
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    __int16 __tmp = *(const volatile __int16 *)__ptr;
+#else
+    __int16 __tmp = __iso_volatile_load16((const volatile __int16 *)__ptr);
+#endif
+    *__ret = reinterpret_cast<_Type&>(__tmp);
+}
+template<class _Type, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_load_relaxed(const volatile _Type *__ptr, _Type *__ret) {
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    __int32 __tmp = *(const volatile __int32 *)__ptr;
+#else
+    __int32 __tmp = __iso_volatile_load32((const volatile __int32 *)__ptr);
+#endif
+    *__ret = reinterpret_cast<_Type&>(__tmp);
+}
+template<class _Type, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_load_relaxed(const volatile _Type *__ptr, _Type *__ret) {
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    __int64 __tmp = *(const volatile __int64 *)__ptr;
+#else
+    __int64 __tmp = __iso_volatile_load64((const volatile __int64 *)__ptr);
+#endif
+    *__ret = reinterpret_cast<_Type&>(__tmp);
+}
+
+template<class _Type>
+void __atomic_load(const volatile _Type *__ptr, _Type *__ret, int __memorder) {
+    switch (__memorder) {
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_load_relaxed(__ptr, __ret); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_load_relaxed(__ptr, __ret); break;
+    default: assert(0);
+    }
+}
+
+template<class _Type, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_store_relaxed(volatile _Type *__ptr, _Type *__val) {
+    auto __t = reinterpret_cast<__int8 *>(__val);
+    auto __d = reinterpret_cast<volatile __int8 *>(__ptr);
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    (void)_InterlockedExchange8(__d, *__t);
+#else
+    __iso_volatile_store8(__d, *__t);
+#endif
+}
+template<class _Type, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_store_relaxed(volatile _Type *__ptr, _Type *__val) {
+    auto __t = reinterpret_cast<__int16 *>(__val);
+    auto __d = reinterpret_cast<volatile __int16 *>(__ptr);
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    (void)_InterlockedExchange16(__d, *__t);
+#else
+    __iso_volatile_store16(__d, *__t);
+#endif
+}
+template<class _Type, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_store_relaxed(volatile _Type *__ptr, _Type *__val) {
+    auto __t = reinterpret_cast<__int32 *>(__val);
+    auto __d = reinterpret_cast<volatile __int32 *>(__ptr);
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    // int cannot be converted to long?...
+    (void)_InterlockedExchange(reinterpret_cast<volatile long *>(__d), *__t);
+#else
+    __iso_volatile_store32(__d, *__t);
+#endif
+}
+template<class _Type, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_store_relaxed(volatile _Type *__ptr, _Type *__val) {
+    auto __t = reinterpret_cast<__int64 *>(__val);
+    auto __d = reinterpret_cast<volatile __int64 *>(__ptr);
+#ifdef _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+    (void)_InterlockedExchange64(__d, *__t);
+#else
+    __iso_volatile_store64(__d, *__t);
+#endif
+}
+
+template<class _Type>
+void __atomic_store(volatile _Type *__ptr, _Type *__val, int __memorder) {
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_store_relaxed(__ptr, __val); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_RELAXED: __atomic_store_relaxed(__ptr, __val); break;
+    default: assert(0);
+    }
+}
+
+template<class _Type, _enable_if_sized_as<_Type,1> = 0>
+bool __atomic_compare_exchange_relaxed(const volatile _Type *__ptr, _Type *__expected, const _Type *__desired) {
+    auto __tmp_desired = reinterpret_cast<const char&>(*__desired);
+    auto __tmp_expected = reinterpret_cast<char&>(*__expected);
+    auto const __old = _InterlockedCompareExchange8((volatile char *)__ptr, __tmp_desired, __tmp_expected);
+    if(__old == __tmp_expected)
+        return true;
+    *__expected = reinterpret_cast<const _Type&>(__old);
+    return false;
+}
+template<class _Type, _enable_if_sized_as<_Type,2> = 0>
+bool __atomic_compare_exchange_relaxed(const volatile _Type *__ptr, _Type *__expected, const _Type *__desired) {
+    auto __tmp_desired = reinterpret_cast<const short&>(*__desired);
+    auto __tmp_expected = reinterpret_cast<short&>(*__expected);
+    auto const __old = _InterlockedCompareExchange16((volatile short *)__ptr, __tmp_desired, __tmp_expected);
+    if(__old == __tmp_expected)
+        return true;
+    *__expected = reinterpret_cast<const _Type&>(__old);
+    return false;
+}
+template<class _Type, _enable_if_sized_as<_Type,4> = 0>
+bool __atomic_compare_exchange_relaxed(const volatile _Type *__ptr, _Type *__expected, const _Type *__desired) {
+    auto __tmp_desired = reinterpret_cast<const long&>(*__desired);
+    auto __tmp_expected = reinterpret_cast<long&>(*__expected);
+    auto const __old = _InterlockedCompareExchange((volatile long *)__ptr, __tmp_desired, __tmp_expected);
+    if(__old == __tmp_expected)
+        return true;
+    *__expected = reinterpret_cast<const _Type&>(__old);
+    return false;
+}
+template<class _Type, _enable_if_sized_as<_Type,8> = 0>
+bool __atomic_compare_exchange_relaxed(const volatile _Type *__ptr, _Type *__expected, const _Type *__desired) {
+    auto __tmp_desired = reinterpret_cast<const __int64&>(*__desired);
+    auto __tmp_expected = reinterpret_cast<__int64&>(*__expected);
+    auto const __old = _InterlockedCompareExchange64((volatile __int64 *)__ptr, __tmp_desired, __tmp_expected);
+    if(__old == __tmp_expected)
+        return true;
+    *__expected = reinterpret_cast<const _Type&>(__old);
+    return false;
+}
+template<class _Type>
+bool __atomic_compare_exchange(_Type volatile *__ptr, _Type *__expected, const _Type *__desired, bool, int __success_memorder, int __failure_memorder) {
+    bool success = false;
+    switch (__stronger_order_msvc(__success_memorder, __failure_memorder)) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); success = __atomic_compare_exchange_relaxed(__ptr, __expected, __desired); break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: success = __atomic_compare_exchange_relaxed(__ptr, __expected, __desired); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); success = __atomic_compare_exchange_relaxed(__ptr, __expected, __desired); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: success = __atomic_compare_exchange_relaxed(__ptr, __expected, __desired); break;
+    default: assert(0);
+    }
+    return success;
+}
+
+template<class _Type, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_exchange_relaxed(const volatile _Type *__ptr, const _Type *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchange8((volatile char *)__ptr, reinterpret_cast<char const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_exchange_relaxed(const volatile _Type *__ptr, const _Type *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchange16((volatile short *)__ptr, reinterpret_cast<short const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_exchange_relaxed(const volatile _Type *__ptr, const _Type *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchange((volatile long *)__ptr, reinterpret_cast<long const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_exchange_relaxed(const volatile _Type *__ptr, const _Type *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchange64((volatile __int64 *)__ptr, reinterpret_cast<__int64 const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type>
+void __atomic_exchange(_Type volatile *__ptr, const _Type *__val, _Type *__ret, int __memorder) {
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_exchange_relaxed(__ptr, __val, __ret);break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_exchange_relaxed(__ptr, __val, __ret); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); __atomic_exchange_relaxed(__ptr, __val, __ret); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_exchange_relaxed(__ptr, __val, __ret); break;
+    default: assert(0);
+    }
+}
+
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_fetch_add_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchangeAdd8((volatile char *)__ptr, reinterpret_cast<char const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_fetch_add_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchangeAdd16((volatile short *)__ptr, reinterpret_cast<short const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_fetch_add_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchangeAdd((volatile long *)__ptr, reinterpret_cast<long const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_fetch_add_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedExchangeAdd64((volatile __int64 *)__ptr, reinterpret_cast<__int64 const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta>
+_Type __atomic_fetch_add(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_fetch_add_relaxed(__ptr, &__val, __dest);break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_fetch_add_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); __atomic_fetch_add_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_fetch_add_relaxed(__ptr, &__val, __dest); break;
+    default: assert(0);
+    }
+    return *__dest;
+}
+template<class _Type, class _Delta>
+_Type __atomic_fetch_sub(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    return __atomic_fetch_add(__ptr, 0-__val, __memorder);
+}
+
+
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_fetch_and_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedAnd8((volatile char *)__ptr, reinterpret_cast<char const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_fetch_and_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedAnd16((volatile short *)__ptr, reinterpret_cast<short const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_fetch_and_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedAnd((volatile long *)__ptr, reinterpret_cast<long const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_fetch_and_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedAnd64((volatile __int64 *)__ptr, reinterpret_cast<__int64 const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta>
+_Type __atomic_fetch_and(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_fetch_and_relaxed(__ptr, &__val, __dest);break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_fetch_and_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); __atomic_fetch_and_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_fetch_and_relaxed(__ptr, &__val, __dest); break;
+    default: assert(0);
+    }
+    return *__dest;
+}
+
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_fetch_xor_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedXor8((volatile char *)__ptr, reinterpret_cast<char const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_fetch_xor_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedXor16((volatile short *)__ptr, reinterpret_cast<short const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_fetch_xor_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedXor((volatile long *)__ptr, reinterpret_cast<long const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_fetch_xor_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedXor64((volatile __int64 *)__ptr, reinterpret_cast<__int64 const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta>
+_Type __atomic_fetch_xor(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_fetch_xor_relaxed(__ptr, &__val, __dest);break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_fetch_xor_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); __atomic_fetch_xor_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_fetch_xor_relaxed(__ptr, &__val, __dest); break;
+    default: assert(0);
+    }
+    return *__dest;
+}
+
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,1> = 0>
+void __atomic_fetch_or_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedOr8((volatile char *)__ptr, reinterpret_cast<char const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,2> = 0>
+void __atomic_fetch_or_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedOr16((volatile short *)__ptr, reinterpret_cast<short const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,4> = 0>
+void __atomic_fetch_or_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedOr((volatile long *)__ptr, reinterpret_cast<long const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta, _enable_if_sized_as<_Type,8> = 0>
+void __atomic_fetch_or_relaxed(const volatile _Type *__ptr, const _Delta *__val, _Type *__ret) {
+    auto const __old = _InterlockedOr64((volatile __int64 *)__ptr, reinterpret_cast<__int64 const&>(*__val));
+    *__ret = reinterpret_cast<_Type const&>(__old);
+}
+template<class _Type, class _Delta>
+_Type __atomic_fetch_or(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    switch (__memorder) {
+    case __ATOMIC_RELEASE: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); __atomic_fetch_or_relaxed(__ptr, &__val, __dest);break;
+    case __ATOMIC_ACQ_REL: _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); _LIBCUDACXX_FALLTHROUGH();
+    case __ATOMIC_CONSUME:
+    case __ATOMIC_ACQUIRE: __atomic_fetch_or_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_SEQ_CST: _LIBCUDACXX_MEMORY_BARRIER(); __atomic_fetch_or_relaxed(__ptr, &__val, __dest); _LIBCUDACXX_COMPILER_OR_MEMORY_BARRIER(); break;
+    case __ATOMIC_RELAXED: __atomic_fetch_or_relaxed(__ptr, &__val, __dest); break;
+    default: assert(0);
+    }
+    return *__dest;
+}
+
+template<class _Type>
+_Type __atomic_load_n(const _Type volatile *__ptr, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    __atomic_load(__ptr, __dest, __memorder);
+    return *__dest;
+}
+
+template<class _Type>
+void __atomic_store_n(_Type volatile *__ptr, _Type __val, int __memorder) {
+    __atomic_store(__ptr, &__val, __memorder);
+}
+
+template<class _Type>
+bool __atomic_compare_exchange_n(_Type volatile *__ptr, _Type *__expected, _Type __desired, bool __weak, int __success_memorder, int __failure_memorder) {
+    return __atomic_compare_exchange(__ptr, __expected, &__desired, __weak, __success_memorder, __failure_memorder);
+}
+
+template<class _Type>
+_Type __atomic_exchange_n(_Type volatile *__ptr, _Type __val, int __memorder) {
+    alignas(_Type) unsigned char __buf[sizeof(_Type)] = {};
+    auto* __dest = reinterpret_cast<_Type*>(__buf);
+
+    __atomic_exchange(__ptr, &__val, __dest, __memorder);
+    return *__dest;
+}
+
+template<class _Type, class _Delta>
+_Type __atomic_fetch_max(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    _Type __expected = __atomic_load_n(__ptr, __ATOMIC_RELAXED);
+    _Type __desired = __expected < __val ? __expected : __val;
+    while(__desired == __val &&
+          !__atomic_compare_exchange_n(__ptr, &__expected, __desired, __memorder, __memorder)) {
+        __desired = __expected > __val ? __expected : __val;
+    }
+    return __expected;
+}
+
+template<class _Type, class _Delta>
+_Type __atomic_fetch_min(_Type volatile *__ptr, _Delta __val, int __memorder) {
+    _Type __expected = __atomic_load_n(__ptr, __ATOMIC_RELAXED);
+    _Type __desired = __expected < __val ? __expected : __val;
+    while(__desired != __val &&
+          !__atomic_compare_exchange_n(__ptr, &__expected, __desired, __memorder, __memorder)) {
+        __desired = __expected < __val ? __expected : __val;
+    }
+    return __expected;
+}
+
+#include "atomic_base.h"
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_nvrtc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_nvrtc.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc435215b542627a516833c5ae585efc559749c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_nvrtc.h
@@ -0,0 +1,17 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_ATOMIC_NVRTC_H
+#define _LIBCUDACXX_ATOMIC_NVRTC_H
+
+#include "cxx_atomic.h"
+
+#endif // _LIBCUDACXX_ATOMIC_NVRTC_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_scopes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_scopes.h
new file mode 100644
index 0000000000000000000000000000000000000000..2bf306ca95555e2d8349877377eed4d267f6e852
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/atomic_scopes.h
@@ -0,0 +1,48 @@
+#ifndef __LIBCUDACXX_ATOMIC_SCOPES_H
+#define __LIBCUDACXX_ATOMIC_SCOPES_H
+
+// REMEMBER CHANGES TO THESE ARE ABI BREAKING
+// TODO: Space values out for potential new scopes
+#ifndef __ATOMIC_BLOCK
+#define __ATOMIC_SYSTEM 0 // 0 indicates default
+#define __ATOMIC_DEVICE 1
+#define __ATOMIC_BLOCK 2
+#define __ATOMIC_THREAD 10
+#endif //__ATOMIC_BLOCK
+
+enum thread_scope {
+    thread_scope_system = __ATOMIC_SYSTEM,
+    thread_scope_device = __ATOMIC_DEVICE,
+    thread_scope_block = __ATOMIC_BLOCK,
+    thread_scope_thread = __ATOMIC_THREAD
+};
+
+#define _LIBCUDACXX_ATOMIC_SCOPE_TYPE ::cuda::thread_scope
+#define _LIBCUDACXX_ATOMIC_SCOPE_DEFAULT ::cuda::thread_scope::system
+
+struct __thread_scope_thread_tag { };
+struct __thread_scope_block_tag { };
+struct __thread_scope_device_tag { };
+struct __thread_scope_system_tag { };
+
+template<int _Scope>  struct __scope_enum_to_tag { };
+/* This would be the implementation once an actual thread-scope backend exists.
+template<> struct __scope_enum_to_tag<(int)thread_scope_thread> {
+    using type = __thread_scope_thread_tag; };
+Until then: */
+template<> struct __scope_enum_to_tag<(int)thread_scope_thread> {
+    using type = __thread_scope_block_tag; };
+template<> struct __scope_enum_to_tag<(int)thread_scope_block> {
+    using type = __thread_scope_block_tag; };
+template<> struct __scope_enum_to_tag<(int)thread_scope_device> {
+    using type = __thread_scope_device_tag; };
+template<> struct __scope_enum_to_tag<(int)thread_scope_system> {
+    using type = __thread_scope_system_tag; };
+
+template <int _Scope>
+_LIBCUDACXX_INLINE_VISIBILITY auto constexpr __scope_tag() ->
+        typename __scope_enum_to_tag<_Scope>::type {
+    return typename __scope_enum_to_tag<_Scope>::type();
+}
+
+#endif // __LIBCUDACXX_ATOMIC_SCOPES_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/cxx_atomic.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/cxx_atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6f7635b73ef1ca80e18b79332b30377d50537d0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/atomic/cxx_atomic.h
@@ -0,0 +1,167 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_CXX_ATOMIC_H
+#define _LIBCUDACXX_CXX_ATOMIC_H
+
+template <typename _Tp, int _Sco>
+struct __cxx_atomic_base_impl {
+  using __underlying_t = _Tp;
+  using __temporary_t = __cxx_atomic_base_impl<_Tp, _Sco>;
+  using __wrap_t = __cxx_atomic_base_impl<_Tp, _Sco>;
+
+  static constexpr int __sco = _Sco;
+
+#if !defined(_LIBCUDACXX_COMPILER_GCC) || (__GNUC__ >= 5)
+  static_assert(is_trivially_copyable<_Tp>::value,
+    "std::atomic<Tp> requires that 'Tp' be a trivially copyable type");
+#endif
+
+  _LIBCUDACXX_CONSTEXPR
+  __cxx_atomic_base_impl() _NOEXCEPT = default;
+  _LIBCUDACXX_CONSTEXPR
+  __cxx_atomic_base_impl(__cxx_atomic_base_impl &&) _NOEXCEPT = default;
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR explicit
+  __cxx_atomic_base_impl(_Tp value) _NOEXCEPT : __a_value(value) {}
+
+  __cxx_atomic_base_impl& operator=(const __cxx_atomic_base_impl &) _NOEXCEPT = default;
+
+  _ALIGNAS(sizeof(_Tp)) _Tp __a_value;
+};
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Tp* __cxx_get_underlying_atomic(__cxx_atomic_base_impl<_Tp, _Sco> * __a) _NOEXCEPT {
+  return &__a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+volatile _Tp* __cxx_get_underlying_atomic(__cxx_atomic_base_impl<_Tp, _Sco> volatile* __a) _NOEXCEPT {
+  return &__a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const _Tp* __cxx_get_underlying_atomic(__cxx_atomic_base_impl<_Tp, _Sco> const* __a) _NOEXCEPT {
+  return &__a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const volatile _Tp* __cxx_get_underlying_atomic(__cxx_atomic_base_impl<_Tp, _Sco> const volatile* __a) _NOEXCEPT {
+  return &__a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+__cxx_atomic_base_impl<_Tp, _Sco>* __cxx_atomic_unwrap(__cxx_atomic_base_impl<_Tp, _Sco>* __a) _NOEXCEPT {
+  return __a;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+volatile __cxx_atomic_base_impl<_Tp, _Sco>* __cxx_atomic_unwrap(__cxx_atomic_base_impl<_Tp, _Sco> volatile* __a) _NOEXCEPT {
+  return __a;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const __cxx_atomic_base_impl<_Tp, _Sco>* __cxx_atomic_unwrap(__cxx_atomic_base_impl<_Tp, _Sco> const* __a) _NOEXCEPT {
+  return __a;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const volatile __cxx_atomic_base_impl<_Tp, _Sco>* __cxx_atomic_unwrap(__cxx_atomic_base_impl<_Tp, _Sco> const volatile* __a) _NOEXCEPT {
+  return __a;
+}
+
+template <typename _Tp, int _Sco>
+struct __cxx_atomic_ref_base_impl {
+  using __underlying_t = _Tp;
+  using __temporary_t = _Tp;
+  using __wrap_t = _Tp;
+
+  static constexpr int __sco = _Sco;
+
+#if !defined(_LIBCUDACXX_COMPILER_GCC) || (__GNUC__ >= 5)
+  static_assert(is_trivially_copyable<_Tp>::value,
+    "std::atomic_ref<Tp> requires that 'Tp' be a trivially copyable type");
+#endif
+
+  _LIBCUDACXX_CONSTEXPR
+  __cxx_atomic_ref_base_impl() _NOEXCEPT = delete;
+  _LIBCUDACXX_CONSTEXPR
+  __cxx_atomic_ref_base_impl(__cxx_atomic_ref_base_impl &&) _NOEXCEPT = default;
+  _LIBCUDACXX_CONSTEXPR
+  __cxx_atomic_ref_base_impl(const __cxx_atomic_ref_base_impl &) _NOEXCEPT = default;
+  _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR explicit
+  __cxx_atomic_ref_base_impl(_Tp& value) _NOEXCEPT : __a_value(&value) {}
+
+  _Tp* __a_value;
+};
+
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Tp* __cxx_get_underlying_atomic(__cxx_atomic_ref_base_impl<_Tp, _Sco>* __a) _NOEXCEPT {
+  return __a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+volatile _Tp* __cxx_get_underlying_atomic(__cxx_atomic_ref_base_impl<_Tp, _Sco> volatile* __a) _NOEXCEPT {
+  return __a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const _Tp* __cxx_get_underlying_atomic(__cxx_atomic_ref_base_impl<_Tp, _Sco> const* __a) _NOEXCEPT {
+  return __a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const volatile _Tp* __cxx_get_underlying_atomic(__cxx_atomic_ref_base_impl<_Tp, _Sco> const volatile* __a) _NOEXCEPT {
+  return __a->__a_value;
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Tp* __cxx_atomic_unwrap(__cxx_atomic_ref_base_impl<_Tp, _Sco>* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(__a);
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+volatile _Tp* __cxx_atomic_unwrap(__cxx_atomic_ref_base_impl<_Tp, _Sco> volatile* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(__a);
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const _Tp* __cxx_atomic_unwrap(__cxx_atomic_ref_base_impl<_Tp, _Sco> const* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(__a);
+}
+template <typename _Tp, int _Sco>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+const volatile _Tp* __cxx_atomic_unwrap(__cxx_atomic_ref_base_impl<_Tp, _Sco> const volatile* __a) _NOEXCEPT {
+  return __cxx_get_underlying_atomic(__a);
+}
+
+template <typename _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+_Tp* __cxx_get_underlying_atomic(_Tp* __a) _NOEXCEPT {
+  return __a;
+}
+
+template <typename _Tp, typename _Up>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+auto __cxx_atomic_wrap_to_base(_Tp*, _Up __val) _NOEXCEPT -> typename _Tp::__wrap_t {
+  return typename _Tp::__wrap_t(__val);
+}
+template <typename _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR
+auto __cxx_atomic_base_temporary(_Tp*) _NOEXCEPT -> typename _Tp::__temporary_t {
+  return typename _Tp::__temporary_t();
+}
+
+template <typename _Tp>
+using __cxx_atomic_underlying_t = typename _Tp::__underlying_t;
+
+#endif //_LIBCUDACXX_CXX_ATOMIC_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/fuchsia/xlocale.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/fuchsia/xlocale.h
new file mode 100644
index 0000000000000000000000000000000000000000..596ddb49bc5f673d4b8842b7753bd1e4ad5d35f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/fuchsia/xlocale.h
@@ -0,0 +1,22 @@
+// -*- C++ -*-
+//===------------------- support/fuchsia/xlocale.h ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_FUCHSIA_XLOCALE_H
+#define _LIBCUDACXX_SUPPORT_FUCHSIA_XLOCALE_H
+
+#if defined(__Fuchsia__)
+
+#include <cstdlib>
+#include <cwchar>
+#include <support/xlocale/__posix_l_fallback.h>
+#include <support/xlocale/__strtonum_fallback.h>
+
+#endif // defined(__Fuchsia__)
+
+#endif // _LIBCUDACXX_SUPPORT_FUCHSIA_XLOCALE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/limits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/limits.h
new file mode 100644
index 0000000000000000000000000000000000000000..db2461204ad90182b5e439c0445cde0044139c78
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/limits.h
@@ -0,0 +1,98 @@
+// -*- C++ -*-
+//===--------------------- support/ibm/limits.h ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_IBM_LIMITS_H
+#define _LIBCUDACXX_SUPPORT_IBM_LIMITS_H
+
+#if !defined(_AIX) // Linux
+#include <math.h> // for HUGE_VAL, HUGE_VALF, HUGE_VALL, and NAN
+
+static const unsigned int _QNAN_F = 0x7fc00000;
+#define NANF (*((float *)(&_QNAN_F)))
+static const unsigned int _QNAN_LDBL128[4] = {0x7ff80000, 0x0, 0x0, 0x0};
+#define NANL (*((long double *)(&_QNAN_LDBL128)))
+static const unsigned int _SNAN_F= 0x7f855555;
+#define NANSF (*((float *)(&_SNAN_F)))
+static const unsigned int _SNAN_D[2] = {0x7ff55555, 0x55555555};
+#define NANS (*((double *)(&_SNAN_D)))
+static const unsigned int _SNAN_LDBL128[4] = {0x7ff55555, 0x55555555, 0x0, 0x0};
+#define NANSL (*((long double *)(&_SNAN_LDBL128)))
+
+#define __builtin_huge_val()     HUGE_VAL
+#define __builtin_huge_valf()    HUGE_VALF
+#define __builtin_huge_vall()    HUGE_VALL
+#define __builtin_nan(__dummy)   NAN
+#define __builtin_nanf(__dummy)  NANF
+#define __builtin_nanl(__dummy)  NANL
+#define __builtin_nans(__dummy)  NANS
+#define __builtin_nansf(__dummy) NANSF
+#define __builtin_nansl(__dummy) NANSL
+
+#else
+
+#include <math.h>
+#include <float.h> // limit constants
+
+#define __builtin_huge_val()     HUGE_VAL  //0x7ff0000000000000
+#define __builtin_huge_valf()    HUGE_VALF //0x7f800000
+#define __builtin_huge_vall()    HUGE_VALL //0x7ff0000000000000
+#define __builtin_nan(__dummy)   nan(__dummy) //0x7ff8000000000000
+#define __builtin_nanf(__dummy)  nanf(__dummy) // 0x7ff80000
+#define __builtin_nanl(__dummy)  nanl(__dummy) //0x7ff8000000000000
+#define __builtin_nans(__dummy)  DBL_SNAN //0x7ff5555555555555
+#define __builtin_nansf(__dummy) FLT_SNAN //0x7f855555
+#define __builtin_nansl(__dummy) DBL_SNAN //0x7ff5555555555555
+
+#define __FLT_MANT_DIG__   FLT_MANT_DIG
+#define __FLT_DIG__        FLT_DIG
+#define __FLT_RADIX__      FLT_RADIX
+#define __FLT_MIN_EXP__    FLT_MIN_EXP
+#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
+#define __FLT_MAX_EXP__    FLT_MAX_EXP
+#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
+#define __FLT_MIN__        FLT_MIN
+#define __FLT_MAX__        FLT_MAX
+#define __FLT_EPSILON__    FLT_EPSILON
+// predefined by XLC on LoP
+#define __FLT_DENORM_MIN__ 1.40129846e-45F
+
+#define __DBL_MANT_DIG__   DBL_MANT_DIG
+#define __DBL_DIG__        DBL_DIG
+#define __DBL_MIN_EXP__    DBL_MIN_EXP
+#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
+#define __DBL_MAX_EXP__    DBL_MAX_EXP
+#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
+#define __DBL_MIN__        DBL_MIN
+#define __DBL_MAX__        DBL_MAX
+#define __DBL_EPSILON__    DBL_EPSILON
+// predefined by XLC on LoP
+#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
+
+#define __LDBL_MANT_DIG__   LDBL_MANT_DIG
+#define __LDBL_DIG__        LDBL_DIG
+#define __LDBL_MIN_EXP__    LDBL_MIN_EXP
+#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
+#define __LDBL_MAX_EXP__    LDBL_MAX_EXP
+#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
+#define __LDBL_MIN__        LDBL_MIN
+#define __LDBL_MAX__        LDBL_MAX
+#define __LDBL_EPSILON__    LDBL_EPSILON
+// predefined by XLC on LoP
+#if __LONGDOUBLE128
+#define __LDBL_DENORM_MIN__ 4.94065645841246544176568792868221e-324L
+#else
+#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
+#endif
+
+// predefined by XLC on LoP
+#define __CHAR_BIT__    8
+
+#endif // _AIX
+
+#endif // _LIBCUDACXX_SUPPORT_IBM_LIMITS_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/locale_mgmt_aix.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/locale_mgmt_aix.h
new file mode 100644
index 0000000000000000000000000000000000000000..1528f4443e45e9137cb08bfd4c62da7fd1342f66
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/locale_mgmt_aix.h
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+//===------------------- support/ibm/locale_mgmt_aix.h --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_IBM_LOCALE_MGMT_AIX_H
+#define _LIBCUDACXX_SUPPORT_IBM_LOCALE_MGMT_AIX_H
+
+#if defined(_AIX)
+#include "cstdlib"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_AIX71)
+// AIX 7.1 and higher has these definitions.  Definitions and stubs
+// are provied here as a temporary workaround on AIX 6.1.
+
+#define LC_COLLATE_MASK         1
+#define LC_CTYPE_MASK           2
+#define LC_MESSAGES_MASK        4
+#define LC_MONETARY_MASK        8
+#define LC_NUMERIC_MASK         16
+#define LC_TIME_MASK            32
+#define LC_ALL_MASK             (LC_COLLATE_MASK | LC_CTYPE_MASK | \
+                                 LC_MESSAGES_MASK | LC_MONETARY_MASK |\
+                                 LC_NUMERIC_MASK | LC_TIME_MASK)
+
+typedef void* locale_t;
+
+// The following are stubs.  They are not supported on AIX 6.1.
+static inline
+locale_t newlocale(int category_mask, const char *locale, locale_t base)
+{
+  _LC_locale_t *newloc, *loc;
+  if ((loc = (_LC_locale_t *)__xopen_locale(locale)) == NULL)
+  {
+    errno = EINVAL;
+    return (locale_t)0;
+  }
+  if ((newloc = (_LC_locale_t *)calloc(1, sizeof(_LC_locale_t))) == NULL)
+  {
+    errno = ENOMEM;
+    return (locale_t)0;
+  }
+  if (!base)
+    base = (_LC_locale_t *)__xopen_locale("C");
+  memcpy(newloc, base, sizeof (_LC_locale_t));
+  if (category_mask & LC_COLLATE_MASK)
+    newloc->lc_collate = loc->lc_collate;
+  if (category_mask & LC_CTYPE_MASK)
+    newloc->lc_ctype = loc->lc_ctype;
+  //if (category_mask & LC_MESSAGES_MASK)
+  //  newloc->lc_messages = loc->lc_messages;
+  if (category_mask & LC_MONETARY_MASK)
+    newloc->lc_monetary = loc->lc_monetary;
+  if (category_mask & LC_TIME_MASK)
+    newloc->lc_time = loc->lc_time;
+  if (category_mask & LC_NUMERIC_MASK)
+    newloc->lc_numeric = loc->lc_numeric;
+  return (locale_t)newloc;
+}
+static inline
+void freelocale(locale_t locobj)
+{
+  free(locobj);
+}
+static inline
+locale_t uselocale(locale_t newloc)
+{
+  return (locale_t)0;
+}
+#endif // !defined(_AIX71)
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(_AIX)
+#endif // _LIBCUDACXX_SUPPORT_IBM_LOCALE_MGMT_AIX_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/support.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/support.h
new file mode 100644
index 0000000000000000000000000000000000000000..162611a04f062041d65dbd572dda1c12e3394c65
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/support.h
@@ -0,0 +1,53 @@
+// -*- C++ -*-
+//===----------------------- support/ibm/support.h ----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_IBM_SUPPORT_H
+#define _LIBCUDACXX_SUPPORT_IBM_SUPPORT_H
+
+extern "builtin" int __popcnt4(unsigned int);
+extern "builtin" int __popcnt8(unsigned long long);
+extern "builtin" unsigned int __cnttz4(unsigned int);
+extern "builtin" unsigned int __cnttz8(unsigned long long);
+extern "builtin" unsigned int __cntlz4(unsigned int);
+extern "builtin" unsigned int __cntlz8(unsigned long long);
+
+// Builtin functions for counting population
+#define __builtin_popcount(x) __popcnt4(x)
+#define __builtin_popcountll(x) __popcnt8(x)
+#if defined(__64BIT__)
+#define __builtin_popcountl(x) __builtin_popcountll(x)
+#else
+#define __builtin_popcountl(x) __builtin_popcount(x)
+#endif
+
+// Builtin functions for counting trailing zeros
+#define __builtin_ctz(x) __cnttz4(x)
+#define __builtin_ctzll(x) __cnttz8(x)
+#if defined(__64BIT__)
+#define __builtin_ctzl(x) __builtin_ctzll(x)
+#else
+#define __builtin_ctzl(x) __builtin_ctz(x)
+#endif
+
+// Builtin functions for counting leading zeros
+#define __builtin_clz(x) __cntlz4(x)
+#define __builtin_clzll(x) __cntlz8(x)
+#if defined(__64BIT__)
+#define __builtin_clzl(x) __builtin_clzll(x)
+#else
+#define __builtin_clzl(x) __builtin_clz(x)
+#endif
+
+#if defined(__64BIT__)
+#define __SIZE_WIDTH__ 64
+#else
+#define __SIZE_WIDTH__ 32
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_IBM_SUPPORT_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/xlocale.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/xlocale.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f44448b2ea79df1231dc621f54ef8ba90f6a9ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/ibm/xlocale.h
@@ -0,0 +1,270 @@
+// -*- C++ -*-
+//===--------------------- support/ibm/xlocale.h -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_IBM_XLOCALE_H
+#define _LIBCUDACXX_SUPPORT_IBM_XLOCALE_H
+#include <support/ibm/locale_mgmt_aix.h>
+
+#if defined(_AIX)
+#include "cstdlib"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_AIX71)
+// AIX 7.1 and higher has these definitions.  Definitions and stubs
+// are provied here as a temporary workaround on AIX 6.1.
+static inline
+int isalnum_l(int c, locale_t locale)
+{
+  return __xisalnum(locale, c);
+}
+static inline
+int isalpha_l(int c, locale_t locale)
+{
+  return __xisalpha(locale, c);
+}
+static inline
+int isblank_l(int c, locale_t locale)
+{
+  return __xisblank(locale, c);
+}
+static inline
+int iscntrl_l(int c, locale_t locale)
+{
+  return __xiscntrl(locale, c);
+}
+static inline
+int isdigit_l(int c, locale_t locale)
+{
+  return __xisdigit(locale, c);
+}
+static inline
+int isgraph_l(int c, locale_t locale)
+{
+  return __xisgraph(locale, c);
+}
+static inline
+int islower_l(int c, locale_t locale)
+{
+  return __xislower(locale, c);
+}
+static inline
+int isprint_l(int c, locale_t locale)
+{
+  return __xisprint(locale, c);
+}
+
+static inline
+int ispunct_l(int c, locale_t locale)
+{
+  return __xispunct(locale, c);
+}
+static inline
+int isspace_l(int c, locale_t locale)
+{
+  return __xisspace(locale, c);
+}
+static inline
+int isupper_l(int c, locale_t locale)
+{
+  return __xisupper(locale, c);
+}
+
+static inline
+int isxdigit_l(int c, locale_t locale)
+{
+  return __xisxdigit(locale, c);
+}
+
+static inline
+int iswalnum_l(wchar_t wc, locale_t locale)
+{
+  return __xiswalnum(locale, wc); 
+}
+
+static inline
+int iswalpha_l(wchar_t wc, locale_t locale)
+{
+  return __xiswalpha(locale, wc);
+}
+
+static inline
+int iswblank_l(wchar_t wc, locale_t locale)
+{
+  return __xiswblank(locale, wc);
+}
+
+static inline
+int iswcntrl_l(wchar_t wc, locale_t locale)
+{
+  return __xiswcntrl(locale, wc);
+}
+
+static inline
+int iswdigit_l(wchar_t wc, locale_t locale)
+{
+  return __xiswdigit(locale, wc);
+}
+
+static inline
+int iswgraph_l(wchar_t wc, locale_t locale)
+{
+  return __xiswgraph(locale, wc);
+}
+
+static inline
+int iswlower_l(wchar_t wc, locale_t locale)
+{
+  return __xiswlower(locale, wc);
+}
+
+static inline
+int iswprint_l(wchar_t wc, locale_t locale)
+{
+  return __xiswprint(locale, wc);
+}
+
+static inline
+int iswpunct_l(wchar_t wc, locale_t locale)
+{
+  return __xiswpunct(locale, wc);
+}
+
+static inline
+int iswspace_l(wchar_t wc, locale_t locale)
+{
+  return __xiswspace(locale, wc);
+}
+
+static inline
+int iswupper_l(wchar_t wc, locale_t locale)
+{
+  return __xiswupper(locale, wc);
+}
+
+static inline
+int iswxdigit_l(wchar_t wc, locale_t locale)
+{
+  return __xiswxdigit(locale, wc);
+}
+
+static inline
+int iswctype_l(wint_t wc, wctype_t desc, locale_t locale)
+{
+  return __xiswctype(locale, wc, desc); 
+}
+
+static inline
+int toupper_l(int c, locale_t locale)
+{
+  return __xtoupper(locale, c);
+}
+static inline
+int tolower_l(int c, locale_t locale)
+{
+  return __xtolower(locale, c);
+}
+static inline
+wint_t towupper_l(wint_t wc, locale_t locale)
+{
+  return __xtowupper(locale, wc);
+}
+static inline
+wint_t towlower_l(wint_t wc, locale_t locale)
+{
+  return __xtowlower(locale, wc);
+}
+
+static inline
+int strcoll_l(const char *__s1, const char *__s2, locale_t locale)
+{
+  return __xstrcoll(locale, __s1, __s2);
+}
+static inline
+int wcscoll_l(const wchar_t *__s1, const wchar_t *__s2, locale_t locale)
+{
+  return __xwcscoll(locale, __s1, __s2);
+}
+static inline
+size_t strxfrm_l(char *__s1, const char *__s2, size_t __n, locale_t locale)
+{
+  return __xstrxfrm(locale, __s1, __s2, __n);
+}
+
+static inline
+size_t wcsxfrm_l(wchar_t *__ws1, const wchar_t *__ws2, size_t __n,
+    locale_t locale)
+{
+  return __xwcsxfrm(locale, __ws1, __ws2, __n);
+}
+#endif // !defined(_AIX71)
+
+// strftime_l() is defined by POSIX. However, AIX 7.1 does not have it
+// implemented yet.
+static inline
+size_t strftime_l(char *__s, size_t __size, const char *__fmt,
+                  const struct tm *__tm, locale_t locale) {
+  return __xstrftime(locale, __s, __size, __fmt, __tm);
+}
+
+// The following are not POSIX routines.  These are quick-and-dirty hacks
+// to make things pretend to work
+static inline
+long long strtoll_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoll(__nptr, __endptr, __base);
+}
+static inline
+long strtol_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtol(__nptr, __endptr, __base);
+}
+static inline
+long double strtold_l(const char *__nptr, char **__endptr,
+    locale_t locale) {
+  return strtold(__nptr, __endptr);
+}
+static inline
+unsigned long long strtoull_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoull(__nptr, __endptr, __base);
+}
+static inline
+unsigned long strtoul_l(const char *__nptr, char **__endptr,
+    int __base, locale_t locale) {
+  return strtoul(__nptr, __endptr, __base);
+}
+
+static inline
+int vasprintf(char **strp, const char *fmt, va_list ap)
+{
+  const size_t buff_size = 256;
+  int str_size;
+  if ((*strp = (char *)malloc(buff_size)) == NULL)
+  {
+    return -1;
+  }
+  if ((str_size = vsnprintf(*strp, buff_size, fmt,  ap)) >= buff_size)
+  {
+    if ((*strp = (char *)realloc(*strp, str_size + 1)) == NULL)
+    {
+      return -1;
+    }
+    str_size = vsnprintf(*strp, str_size + 1, fmt,  ap);
+  }
+  return str_size;
+}  
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(_AIX)
+#endif // _LIBCUDACXX_SUPPORT_IBM_XLOCALE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/musl/xlocale.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/musl/xlocale.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b7a6883bce6ed4b4e2f1ef68195a39181724ee6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/musl/xlocale.h
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===------------------- support/musl/xlocale.h ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This adds support for the extended locale functions that are currently
+// missing from the Musl C library.
+//
+// This only works when the specified locale is "C" or "POSIX", but that's
+// about as good as we can do without implementing full xlocale support
+// in Musl.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_MUSL_XLOCALE_H
+#define _LIBCUDACXX_SUPPORT_MUSL_XLOCALE_H
+
+#include <cstdlib>
+#include <cwchar>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static inline long long strtoll_l(const char *nptr, char **endptr, int base,
+                                  locale_t) {
+  return strtoll(nptr, endptr, base);
+}
+
+static inline unsigned long long strtoull_l(const char *nptr, char **endptr,
+                                            int base, locale_t) {
+  return strtoull(nptr, endptr, base);
+}
+
+static inline long long wcstoll_l(const wchar_t *nptr, wchar_t **endptr,
+                                  int base, locale_t) {
+  return wcstoll(nptr, endptr, base);
+}
+
+static inline unsigned long long wcstoull_l(const wchar_t *nptr,
+                                            wchar_t **endptr, int base,
+                                            locale_t) {
+  return wcstoull(nptr, endptr, base);
+}
+
+static inline long double wcstold_l(const wchar_t *nptr, wchar_t **endptr,
+                                    locale_t) {
+  return wcstold(nptr, endptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_MUSL_XLOCALE_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/newlib/xlocale.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/newlib/xlocale.h
new file mode 100644
index 0000000000000000000000000000000000000000..8be7c6b43c4fb538687cc9b47f6df829df0071f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/newlib/xlocale.h
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_NEWLIB_XLOCALE_H
+#define _LIBCUDACXX_SUPPORT_NEWLIB_XLOCALE_H
+
+#if defined(_NEWLIB_VERSION)
+
+#include <cstdlib>
+#include <clocale>
+#include <cwctype>
+#include <ctype.h>
+#if !defined(__NEWLIB__) || __NEWLIB__ < 2 || \
+    __NEWLIB__ == 2 && __NEWLIB_MINOR__ < 5
+#include <support/xlocale/__nop_locale_mgmt.h>
+#include <support/xlocale/__posix_l_fallback.h>
+#include <support/xlocale/__strtonum_fallback.h>
+#endif
+
+#endif // _NEWLIB_VERSION
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/floatingpoint.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/floatingpoint.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f1628fbe4f59b078a1025167ad1b9c67d74841a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/floatingpoint.h
@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#define atof sun_atof
+#define strtod sun_strtod
+#include_next "floatingpoint.h"
+#undef atof
+#undef strtod
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/wchar.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/wchar.h
new file mode 100644
index 0000000000000000000000000000000000000000..9dc9ac3f006cb125f2d349e2042967fe7ddc684b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/wchar.h
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#define iswalpha sun_iswalpha
+#define iswupper sun_iswupper
+#define iswlower sun_iswlower
+#define iswdigit sun_iswdigit
+#define iswxdigit sun_iswxdigit
+#define iswalnum sun_iswalnum
+#define iswspace sun_iswspace
+#define iswpunct sun_iswpunct
+#define iswprint sun_iswprint
+#define iswgraph sun_iswgraph
+#define iswcntrl sun_iswcntrl
+#define iswctype sun_iswctype
+#define towlower sun_towlower
+#define towupper sun_towupper
+#define wcswcs sun_wcswcs
+#define wcswidth sun_wcswidth
+#define wcwidth sun_wcwidth
+#define wctype sun_wctype
+#define _WCHAR_T 1
+#include_next "wchar.h"
+#undef iswalpha 
+#undef iswupper
+#undef iswlower
+#undef iswdigit
+#undef iswxdigit
+#undef iswalnum
+#undef iswspace
+#undef iswpunct
+#undef iswprint
+#undef iswgraph
+#undef iswcntrl
+#undef iswctype
+#undef towlower
+#undef towupper
+#undef wcswcs
+#undef wcswidth
+#undef wcwidth
+#undef wctype
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/xlocale.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/xlocale.h
new file mode 100644
index 0000000000000000000000000000000000000000..05131f0272ef10a00873f11b0bb1b00035f4530b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/solaris/xlocale.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+////////////////////////////////////////////////////////////////////////////////
+// Minimal xlocale implementation for Solaris.  This implements the subset of
+// the xlocale APIs that libc++ depends on.
+////////////////////////////////////////////////////////////////////////////////
+#ifndef __XLOCALE_H_INCLUDED
+#define __XLOCALE_H_INCLUDED
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...);
+int asprintf_l(char **__s, locale_t __l, const char *__format, ...);
+
+int sscanf_l(const char *__s, locale_t __l, const char *__format, ...);
+
+int toupper_l(int __c, locale_t __l);
+int tolower_l(int __c, locale_t __l);
+
+struct lconv *localeconv(void);
+struct lconv *localeconv_l(locale_t __l);
+
+// FIXME: These are quick-and-dirty hacks to make things pretend to work
+static inline
+long long strtoll_l(const char *__nptr, char **__endptr,
+    int __base, locale_t __loc) {
+  return strtoll(__nptr, __endptr, __base);
+}
+static inline
+long strtol_l(const char *__nptr, char **__endptr,
+    int __base, locale_t __loc) {
+  return strtol(__nptr, __endptr, __base);
+}
+static inline
+unsigned long long strtoull_l(const char *__nptr, char **__endptr,
+    int __base, locale_t __loc) {
+  return strtoull(__nptr, __endptr, __base);
+}
+static inline
+unsigned long strtoul_l(const char *__nptr, char **__endptr,
+    int __base, locale_t __loc) {
+  return strtoul(__nptr, __endptr, __base);
+}
+static inline
+float strtof_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtof(__nptr, __endptr);
+}
+static inline
+double strtod_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtod(__nptr, __endptr);
+}
+static inline
+long double strtold_l(const char *__nptr, char **__endptr,
+    locale_t __loc) {
+  return strtold(__nptr, __endptr);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/limits_msvc_win32.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/limits_msvc_win32.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc5ed151520cdba376a8fb9770c90a2c193f7ae8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/limits_msvc_win32.h
@@ -0,0 +1,77 @@
+// -*- C++ -*-
+//===------------------ support/win32/limits_msvc_win32.h -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
+#define _LIBCUDACXX_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
+
+#if !defined(_LIBCUDACXX_MSVCRT)
+#error "This header complements the Microsoft C Runtime library, and should not be included otherwise."
+#endif
+#if defined(__clang__)
+#error "This header should only be included when using Microsofts C1XX frontend"
+#endif
+
+#include <limits.h> // CHAR_BIT
+#include <float.h> // limit constants
+#include <math.h> // HUGE_VAL
+#include <ymath.h> // internal MSVC header providing the needed functionality
+
+#define __CHAR_BIT__       CHAR_BIT
+
+#define __FLT_MANT_DIG__   FLT_MANT_DIG
+#define __FLT_DIG__        FLT_DIG
+#define __FLT_RADIX__      FLT_RADIX
+#define __FLT_MIN_EXP__    FLT_MIN_EXP
+#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
+#define __FLT_MAX_EXP__    FLT_MAX_EXP
+#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
+#define __FLT_MIN__        FLT_MIN
+#define __FLT_MAX__        FLT_MAX
+#define __FLT_EPSILON__    FLT_EPSILON
+// predefined by MinGW GCC
+#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
+
+#define __DBL_MANT_DIG__   DBL_MANT_DIG
+#define __DBL_DIG__        DBL_DIG
+#define __DBL_RADIX__      DBL_RADIX
+#define __DBL_MIN_EXP__    DBL_MIN_EXP
+#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
+#define __DBL_MAX_EXP__    DBL_MAX_EXP
+#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
+#define __DBL_MIN__        DBL_MIN
+#define __DBL_MAX__        DBL_MAX
+#define __DBL_EPSILON__    DBL_EPSILON
+// predefined by MinGW GCC
+#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
+
+#define __LDBL_MANT_DIG__   LDBL_MANT_DIG
+#define __LDBL_DIG__        LDBL_DIG
+#define __LDBL_RADIX__      LDBL_RADIX
+#define __LDBL_MIN_EXP__    LDBL_MIN_EXP
+#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
+#define __LDBL_MAX_EXP__    LDBL_MAX_EXP
+#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
+#define __LDBL_MIN__        LDBL_MIN
+#define __LDBL_MAX__        LDBL_MAX
+#define __LDBL_EPSILON__    LDBL_EPSILON
+// predefined by MinGW GCC
+#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
+
+// __builtin replacements/workarounds
+#if _MSC_VER < 1934
+#define __builtin_huge_vall()    _LInf._Long_double
+#define __builtin_nanl(__dummmy) _LNan._Long_double
+#define __builtin_nansl(__dummy) _LSnan._Long_double
+#else
+#define __builtin_huge_vall()    __builtin_huge_val()
+#define __builtin_nanl(__v)      __builtin_nan(__v)
+#define __builtin_nansl(__v)     __builtin_nans(__v)
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_WIN32_LIMITS_MSVC_WIN32_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/locale_win32.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/locale_win32.h
new file mode 100644
index 0000000000000000000000000000000000000000..738dfd8657b56e0ea1f7743ce04d45ae9243710e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/win32/locale_win32.h
@@ -0,0 +1,198 @@
+// -*- C++ -*-
+//===--------------------- support/win32/locale_win32.h -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_WIN32_LOCALE_WIN32_H
+#define _LIBCUDACXX_SUPPORT_WIN32_LOCALE_WIN32_H
+
+#include <__config>
+#include <stdio.h>
+#include <xlocinfo.h> // _locale_t
+#include <__nullptr>
+
+#define LC_COLLATE_MASK _M_COLLATE
+#define LC_CTYPE_MASK _M_CTYPE
+#define LC_MONETARY_MASK _M_MONETARY
+#define LC_NUMERIC_MASK _M_NUMERIC
+#define LC_TIME_MASK _M_TIME
+#define LC_MESSAGES_MASK _M_MESSAGES
+#define LC_ALL_MASK (  LC_COLLATE_MASK \
+                     | LC_CTYPE_MASK \
+                     | LC_MESSAGES_MASK \
+                     | LC_MONETARY_MASK \
+                     | LC_NUMERIC_MASK \
+                     | LC_TIME_MASK )
+
+class locale_t {
+public:
+    locale_t()
+        : __locale(nullptr), __locale_str(nullptr) {}
+    locale_t(std::nullptr_t)
+        : __locale(nullptr), __locale_str(nullptr) {}
+    locale_t(_locale_t __xlocale, const char* __xlocale_str)
+        : __locale(__xlocale), __locale_str(__xlocale_str) {}
+
+    friend bool operator==(const locale_t& __left, const locale_t& __right) {
+        return __left.__locale == __right.__locale;
+    }
+
+    friend bool operator==(const locale_t& __left, int __right) {
+        return __left.__locale == nullptr && __right == 0;
+    }
+
+    friend bool operator==(const locale_t& __left, long long __right) {
+        return __left.__locale == nullptr && __right == 0;
+    }
+
+    friend bool operator==(const locale_t& __left, std::nullptr_t) {
+        return __left.__locale == nullptr;
+    }
+
+    friend bool operator==(int __left, const locale_t& __right) {
+        return __left == 0 && nullptr == __right.__locale;
+    }
+
+    friend bool operator==(std::nullptr_t, const locale_t& __right) {
+        return nullptr == __right.__locale;
+    }
+
+    friend bool operator!=(const locale_t& __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(const locale_t& __left, int __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(const locale_t& __left, long long __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(const locale_t& __left, std::nullptr_t __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(int __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(std::nullptr_t __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    operator bool() const {
+        return __locale != nullptr;
+    }
+
+    const char* __get_locale() const { return __locale_str; }
+
+    operator _locale_t() const {
+        return __locale;
+    }
+private:
+    _locale_t __locale;
+    const char* __locale_str;
+};
+
+// Locale management functions
+#define freelocale _free_locale
+// FIXME: base currently unused. Needs manual work to construct the new locale
+locale_t newlocale( int mask, const char * locale, locale_t base );
+// uselocale can't be implemented on Windows because Windows allows partial modification
+// of thread-local locale and so _get_current_locale() returns a copy while uselocale does
+// not create any copies.
+// We can still implement raii even without uselocale though.
+
+
+lconv *localeconv_l( locale_t loc );
+size_t mbrlen_l( const char *__restrict s, size_t n,
+                 mbstate_t *__restrict ps, locale_t loc);
+size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                    size_t len, mbstate_t *__restrict ps, locale_t loc );
+size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
+                  locale_t loc);
+size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
+                  size_t n, mbstate_t *__restrict ps, locale_t loc);
+size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
+                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc);
+size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
+                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc);
+wint_t btowc_l( int c, locale_t loc );
+int wctob_l( wint_t c, locale_t loc );
+
+decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l );
+
+// the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
+#define mbtowc_l _mbtowc_l
+#define strtoll_l _strtoi64_l
+#define strtoull_l _strtoui64_l
+#define strtod_l _strtod_l
+#if defined(_LIBCUDACXX_MSVCRT)
+#define strtof_l _strtof_l
+#define strtold_l _strtold_l
+#else
+float strtof_l(const char*, char**, locale_t);
+long double strtold_l(const char*, char**, locale_t);
+#endif
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int
+islower_l(int c, _locale_t loc)
+{
+ return _islower_l((int)c, loc);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int
+isupper_l(int c, _locale_t loc)
+{
+ return _isupper_l((int)c, loc);
+}
+
+#define isdigit_l _isdigit_l
+#define isxdigit_l _isxdigit_l
+#define strcoll_l _strcoll_l
+#define strxfrm_l _strxfrm_l
+#define wcscoll_l _wcscoll_l
+#define wcsxfrm_l _wcsxfrm_l
+#define toupper_l _toupper_l
+#define tolower_l _tolower_l
+#define iswspace_l _iswspace_l
+#define iswprint_l _iswprint_l
+#define iswcntrl_l _iswcntrl_l
+#define iswupper_l _iswupper_l
+#define iswlower_l _iswlower_l
+#define iswalpha_l _iswalpha_l
+#define iswdigit_l _iswdigit_l
+#define iswpunct_l _iswpunct_l
+#define iswxdigit_l _iswxdigit_l
+#define towupper_l _towupper_l
+#define towlower_l _towlower_l
+#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
+#define strftime_l( __s, __l, __f, __tm, __loc ) strftime( __s, __l, __f, __tm )
+#else
+#define strftime_l _strftime_l
+#endif
+#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
+#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
+#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
+#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
+_LIBCUDACXX_FUNC_VIS int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...);
+_LIBCUDACXX_FUNC_VIS int asprintf_l( char **ret, locale_t loc, const char *format, ... );
+_LIBCUDACXX_FUNC_VIS int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
+
+// not-so-pressing FIXME: use locale to determine blank characters
+inline int isblank_l( int c, locale_t /*loc*/ )
+{
+    return ( c == ' ' || c == '\t' );
+}
+inline int iswblank_l( wint_t c, locale_t /*loc*/ )
+{
+    return ( c == L' ' || c == L'\t' );
+}
+
+#endif // _LIBCUDACXX_SUPPORT_WIN32_LOCALE_WIN32_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__nop_locale_mgmt.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__nop_locale_mgmt.h
new file mode 100644
index 0000000000000000000000000000000000000000..12502e8f735ba72d8c5cb4b2cccd8e27a6066838
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__nop_locale_mgmt.h
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//===------------  support/xlocale/__nop_locale_mgmt.h -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
+#define _LIBCUDACXX_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Patch over lack of extended locale support
+typedef void *locale_t;
+static inline locale_t duplocale(locale_t) {
+  return NULL;
+}
+
+static inline void freelocale(locale_t) {
+}
+
+static inline locale_t newlocale(int, const char *, locale_t) {
+  return NULL;
+}
+
+static inline locale_t uselocale(locale_t) {
+  return NULL;
+}
+
+#define LC_COLLATE_MASK  (1 << LC_COLLATE)
+#define LC_CTYPE_MASK    (1 << LC_CTYPE)
+#define LC_MESSAGES_MASK (1 << LC_MESSAGES)
+#define LC_MONETARY_MASK (1 << LC_MONETARY)
+#define LC_NUMERIC_MASK  (1 << LC_NUMERIC)
+#define LC_TIME_MASK     (1 << LC_TIME)
+#define LC_ALL_MASK (LC_COLLATE_MASK|\
+                     LC_CTYPE_MASK|\
+                     LC_MONETARY_MASK|\
+                     LC_NUMERIC_MASK|\
+                     LC_TIME_MASK|\
+                     LC_MESSAGES_MASK)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__posix_l_fallback.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__posix_l_fallback.h
new file mode 100644
index 0000000000000000000000000000000000000000..9aff01bc278e34d07ac0e1bee3d71368c07fbaff
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__posix_l_fallback.h
@@ -0,0 +1,164 @@
+// -*- C++ -*-
+//===--------------- support/xlocale/__posix_l_fallback.h -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// These are reimplementations of some extended locale functions ( *_l ) that
+// are normally part of POSIX.  This shared implementation provides parts of the
+// extended locale support for libc's that normally don't have any (like
+// Android's bionic and Newlib).
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
+#define _LIBCUDACXX_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isalnum_l(int c, locale_t) {
+  return ::isalnum(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isalpha_l(int c, locale_t) {
+  return ::isalpha(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isblank_l(int c, locale_t) {
+  return ::isblank(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iscntrl_l(int c, locale_t) {
+  return ::iscntrl(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isdigit_l(int c, locale_t) {
+  return ::isdigit(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isgraph_l(int c, locale_t) {
+  return ::isgraph(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int islower_l(int c, locale_t) {
+  return ::islower(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isprint_l(int c, locale_t) {
+  return ::isprint(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int ispunct_l(int c, locale_t) {
+  return ::ispunct(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isspace_l(int c, locale_t) {
+  return ::isspace(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isupper_l(int c, locale_t) {
+  return ::isupper(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int isxdigit_l(int c, locale_t) {
+  return ::isxdigit(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswalnum_l(wint_t c, locale_t) {
+  return ::iswalnum(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswalpha_l(wint_t c, locale_t) {
+  return ::iswalpha(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswblank_l(wint_t c, locale_t) {
+  return ::iswblank(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswcntrl_l(wint_t c, locale_t) {
+  return ::iswcntrl(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswdigit_l(wint_t c, locale_t) {
+  return ::iswdigit(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswgraph_l(wint_t c, locale_t) {
+  return ::iswgraph(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswlower_l(wint_t c, locale_t) {
+  return ::iswlower(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswprint_l(wint_t c, locale_t) {
+  return ::iswprint(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswpunct_l(wint_t c, locale_t) {
+  return ::iswpunct(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswspace_l(wint_t c, locale_t) {
+  return ::iswspace(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswupper_l(wint_t c, locale_t) {
+  return ::iswupper(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int iswxdigit_l(wint_t c, locale_t) {
+  return ::iswxdigit(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int toupper_l(int c, locale_t) {
+  return ::toupper(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int tolower_l(int c, locale_t) {
+  return ::tolower(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY wint_t towupper_l(wint_t c, locale_t) {
+  return ::towupper(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY wint_t towlower_l(wint_t c, locale_t) {
+  return ::towlower(c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int strcoll_l(const char *s1, const char *s2,
+                                               locale_t) {
+  return ::strcoll(s1, s2);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY size_t strxfrm_l(char *dest, const char *src,
+                                                  size_t n, locale_t) {
+  return ::strxfrm(dest, src, n);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY size_t strftime_l(char *s, size_t max,
+                                                   const char *format,
+                                                   const struct tm *tm, locale_t) {
+  return ::strftime(s, max, format, tm);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY int wcscoll_l(const wchar_t *ws1,
+                                               const wchar_t *ws2, locale_t) {
+  return ::wcscoll(ws1, ws2);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY size_t wcsxfrm_l(wchar_t *dest, const wchar_t *src,
+                                                  size_t n, locale_t) {
+  return ::wcsxfrm(dest, src, n);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__strtonum_fallback.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__strtonum_fallback.h
new file mode 100644
index 0000000000000000000000000000000000000000..18f77d600aa134c46a3b27c033ad22566be56059
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/cuda/std/detail/libcxx/include/support/xlocale/__strtonum_fallback.h
@@ -0,0 +1,66 @@
+// -*- C++ -*-
+//===-------------- support/xlocale/__strtonum_fallback.h -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// These are reimplementations of some extended locale functions ( *_l ) that
+// aren't part of POSIX.  They are widely available though (GLIBC, BSD, maybe
+// others).  The unifying aspect in this case is that all of these functions
+// convert strings to some numeric type.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
+#define _LIBCUDACXX_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+inline _LIBCUDACXX_INLINE_VISIBILITY float strtof_l(const char *nptr,
+                                                char **endptr, locale_t) {
+  return ::strtof(nptr, endptr);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY double strtod_l(const char *nptr,
+                                                 char **endptr, locale_t) {
+  return ::strtod(nptr, endptr);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY long double strtold_l(const char *nptr,
+                                                       char **endptr, locale_t) {
+  return ::strtold(nptr, endptr);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY long long
+strtoll_l(const char *nptr, char **endptr, int base, locale_t) {
+  return ::strtoll(nptr, endptr, base);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY unsigned long long
+strtoull_l(const char *nptr, char **endptr, int base, locale_t) {
+  return ::strtoull(nptr, endptr, base);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY long long
+wcstoll_l(const wchar_t *nptr, wchar_t **endptr, int base, locale_t) {
+  return ::wcstoll(nptr, endptr, base);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY unsigned long long
+wcstoull_l(const wchar_t *nptr, wchar_t **endptr, int base, locale_t) {
+  return ::wcstoull(nptr, endptr, base);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY long double wcstold_l(const wchar_t *nptr,
+                                                       wchar_t **endptr, locale_t) {
+  return ::wcstold(nptr, endptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _LIBCUDACXX_SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__preprocessor b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__preprocessor
new file mode 100644
index 0000000000000000000000000000000000000000..af9382bd13ace6aea54b06d2367febf3ce73ddb9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__preprocessor
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__GNUC__)
+#pragma GCC system_header
+#endif
+
+// For all compilers and dialects this header defines:
+//  _NV_EVAL
+//  _NV_IF
+//  _NV_CONCAT_EVAL
+// For C++11 and up it defines:
+//  _NV_STRIP_PAREN
+//  _NV_DISPATCH_N_ARY
+//  _NV_FIRST_ARG
+//  _NV_REMOVE_PAREN
+
+#if defined(_NV_TARGET_CPP11)
+#  define _NV_EVAL1(...) __VA_ARGS__
+#  define _NV_EVAL(...) _NV_EVAL1(__VA_ARGS__)
+#else
+#  define _NV_EVAL1(x) x
+#  define _NV_EVAL(x) _NV_EVAL1(x)
+#endif // C++11
+
+#define _NV_CONCAT_EVAL1(l, r) _NV_EVAL(l ## r)
+#define _NV_CONCAT_EVAL(l, r) _NV_CONCAT_EVAL1(l, r)
+
+#define _NV_IF_0(t, f) f
+#define _NV_IF_1(t, f) t
+
+#define _NV_IF_BIT(b) _NV_EVAL(_NV_IF_##b)
+#define _NV_IF__EVAL(fn, t, f) _NV_EVAL(fn(t, f))
+#define _NV_IF_EVAL(cond, t, f) _NV_IF__EVAL(_NV_IF_BIT(cond), t, f)
+
+#define _NV_IF1(cond, t, f) _NV_IF_EVAL(cond, t, f)
+#define _NV_IF(cond, t, f) _NV_IF1(_NV_EVAL(cond), _NV_EVAL(t), _NV_EVAL(f))
+
+#if defined(_NV_TARGET_CPP11)
+
+// The below mechanisms were derived from: https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
+
+#define _NV_ARG32(...) _NV_EVAL(_NV_ARG32_0(__VA_ARGS__))
+#define _NV_ARG32_0(                                                                         \
+    _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15,                    \
+    _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) _31
+
+#define _NV_HAS_COMMA(...) _NV_ARG32(__VA_ARGS__,   \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
+
+#define _NV_TRIGGER_PARENTHESIS_(...) ,
+
+#define _NV_ISEMPTY(...)                                                    \
+    _NV_ISEMPTY0(                                                           \
+          /* test if there is just one argument, eventually an empty        \
+             one */                                                         \
+          _NV_EVAL(_NV_HAS_COMMA(__VA_ARGS__)),                                       \
+          /* test if _TRIGGER_PARENTHESIS_ together with the argument       \
+             adds a comma */                                                \
+          _NV_EVAL(_NV_HAS_COMMA(_NV_TRIGGER_PARENTHESIS_ __VA_ARGS__)),              \
+          /* test if the argument together with a parenthesis               \
+             adds a comma */                                                \
+          _NV_EVAL(_NV_HAS_COMMA(__VA_ARGS__ (/*empty*/))),                           \
+          /* test if placing it between _TRIGGER_PARENTHESIS_ and the       \
+             parenthesis adds a comma */                                    \
+          _NV_EVAL(_NV_HAS_COMMA(_NV_TRIGGER_PARENTHESIS_ __VA_ARGS__ (/*empty*/)))   \
+          )
+
+#define _NV_PASTE5(_0, _1, _2, _3, _4) _0 ## _1 ## _2 ## _3 ## _4
+#define _NV_ISEMPTY0(_0, _1, _2, _3) _NV_HAS_COMMA(_NV_PASTE5(_NV_IS_EMPTY_CASE_, _0, _1, _2, _3))
+#define _NV_IS_EMPTY_CASE_0001 ,
+
+
+#define _NV_REMOVE_PAREN(...) _NV_REMOVE_PAREN1(__VA_ARGS__)
+#define _NV_REMOVE_PAREN1(...) _NV_STRIP_PAREN(_NV_IF(_NV_TEST_PAREN(__VA_ARGS__), (_NV_STRIP_PAREN(__VA_ARGS__)), (__VA_ARGS__)))
+
+#define _NV_STRIP_PAREN2(...) __VA_ARGS__
+#define _NV_STRIP_PAREN1(...) _NV_STRIP_PAREN2 __VA_ARGS__
+#define _NV_STRIP_PAREN(...) _NV_STRIP_PAREN1(__VA_ARGS__)
+
+#define _NV_TEST_PAREN(...) _NV_TEST_PAREN1(__VA_ARGS__)
+#define _NV_TEST_PAREN1(...) _NV_TEST_PAREN2(_NV_TEST_PAREN_DUMMY __VA_ARGS__)
+#define _NV_TEST_PAREN2(...) _NV_TEST_PAREN3(_NV_CONCAT_EVAL(_, __VA_ARGS__))
+#define _NV_TEST_PAREN3(...) _NV_EVAL(_NV_FIRST_ARG(__VA_ARGS__))
+
+#define __NV_PAREN_YES 1
+#define __NV_PAREN_NO 0
+
+#define _NV_TEST_PAREN_DUMMY(...) _NV_PAREN_YES
+#define __NV_TEST_PAREN_DUMMY     __NV_PAREN_NO,
+
+#define _NV_FIRST_ARG1(x, ...) x
+#define _NV_FIRST_ARG(x, ...) _NV_FIRST_ARG1(x)
+
+#define _NV_REMOVE_FIRST_ARGS1(...) __VA_ARGS__
+#define _NV_REMOVE_FIRST_ARGS(x, ...) _NV_REMOVE_FIRST_ARGS1(__VA_ARGS__)
+
+#define _NV_NUM_ARGS(...) _NV_NUM_ARGS0(__VA_ARGS__)
+#define _NV_NUM_ARGS0(...) _NV_EVAL(_NV_NUM_ARGS1(__VA_ARGS__))
+#define _NV_NUM_ARGS1(...) _NV_IF(_NV_ISEMPTY(__VA_ARGS__), 0, _NV_NUM_ARGS2(__VA_ARGS__))
+#define _NV_NUM_ARGS2(...) _NV_ARG32(__VA_ARGS__,   \
+    31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16, \
+    15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+
+#define _NV_DISPATCH_N_IMPL1(name, ...) _NV_EVAL(name(__VA_ARGS__))
+#define _NV_DISPATCH_N_IMPL0(depth, name, ...) _NV_DISPATCH_N_IMPL1(_NV_CONCAT_EVAL(name, depth), __VA_ARGS__)
+#define _NV_DISPATCH_N_IMPL(name, ...) _NV_DISPATCH_N_IMPL0(_NV_NUM_ARGS(__VA_ARGS__), name, __VA_ARGS__)
+#define _NV_DISPATCH_N_ARY(name, ...) _NV_DISPATCH_N_IMPL(name, __VA_ARGS__)
+
+#endif // C++11
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__target_macros b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__target_macros
new file mode 100644
index 0000000000000000000000000000000000000000..0718884057dcf5861eee30bc58de70ebc3762495
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/detail/__target_macros
@@ -0,0 +1,516 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _NV__TARGET_MACROS
+#define _NV__TARGET_MACROS
+
+#include "__preprocessor"
+
+#if defined(__GNUC__)
+#pragma GCC system_header
+#endif
+
+#  define _NV_TARGET_ARCH_TO_SELECTOR_350 nv::target::sm_35
+#  define _NV_TARGET_ARCH_TO_SELECTOR_370 nv::target::sm_37
+#  define _NV_TARGET_ARCH_TO_SELECTOR_500 nv::target::sm_50
+#  define _NV_TARGET_ARCH_TO_SELECTOR_520 nv::target::sm_52
+#  define _NV_TARGET_ARCH_TO_SELECTOR_530 nv::target::sm_53
+#  define _NV_TARGET_ARCH_TO_SELECTOR_600 nv::target::sm_60
+#  define _NV_TARGET_ARCH_TO_SELECTOR_610 nv::target::sm_61
+#  define _NV_TARGET_ARCH_TO_SELECTOR_620 nv::target::sm_62
+#  define _NV_TARGET_ARCH_TO_SELECTOR_700 nv::target::sm_70
+#  define _NV_TARGET_ARCH_TO_SELECTOR_720 nv::target::sm_72
+#  define _NV_TARGET_ARCH_TO_SELECTOR_750 nv::target::sm_75
+#  define _NV_TARGET_ARCH_TO_SELECTOR_800 nv::target::sm_80
+#  define _NV_TARGET_ARCH_TO_SELECTOR_860 nv::target::sm_86
+#  define _NV_TARGET_ARCH_TO_SELECTOR_870 nv::target::sm_87
+#  define _NV_TARGET_ARCH_TO_SELECTOR_890 nv::target::sm_89
+#  define _NV_TARGET_ARCH_TO_SELECTOR_900 nv::target::sm_90
+
+#  define _NV_TARGET_ARCH_TO_SM_350 35
+#  define _NV_TARGET_ARCH_TO_SM_370 37
+#  define _NV_TARGET_ARCH_TO_SM_500 50
+#  define _NV_TARGET_ARCH_TO_SM_520 52
+#  define _NV_TARGET_ARCH_TO_SM_530 53
+#  define _NV_TARGET_ARCH_TO_SM_600 60
+#  define _NV_TARGET_ARCH_TO_SM_610 61
+#  define _NV_TARGET_ARCH_TO_SM_620 62
+#  define _NV_TARGET_ARCH_TO_SM_700 70
+#  define _NV_TARGET_ARCH_TO_SM_720 72
+#  define _NV_TARGET_ARCH_TO_SM_750 75
+#  define _NV_TARGET_ARCH_TO_SM_800 80
+#  define _NV_TARGET_ARCH_TO_SM_860 86
+#  define _NV_TARGET_ARCH_TO_SM_870 87
+#  define _NV_TARGET_ARCH_TO_SM_890 89
+#  define _NV_TARGET_ARCH_TO_SM_900 90
+
+// Only enable when compiling for CUDA/stdpar
+#if defined(_NV_COMPILER_NVCXX) && defined(_NVHPC_CUDA)
+
+#  define _NV_TARGET_VAL_SM_35 nv::target::sm_35
+#  define _NV_TARGET_VAL_SM_37 nv::target::sm_37
+#  define _NV_TARGET_VAL_SM_50 nv::target::sm_50
+#  define _NV_TARGET_VAL_SM_52 nv::target::sm_52
+#  define _NV_TARGET_VAL_SM_53 nv::target::sm_53
+#  define _NV_TARGET_VAL_SM_60 nv::target::sm_60
+#  define _NV_TARGET_VAL_SM_61 nv::target::sm_61
+#  define _NV_TARGET_VAL_SM_62 nv::target::sm_62
+#  define _NV_TARGET_VAL_SM_70 nv::target::sm_70
+#  define _NV_TARGET_VAL_SM_72 nv::target::sm_72
+#  define _NV_TARGET_VAL_SM_75 nv::target::sm_75
+#  define _NV_TARGET_VAL_SM_80 nv::target::sm_80
+#  define _NV_TARGET_VAL_SM_86 nv::target::sm_86
+#  define _NV_TARGET_VAL_SM_87 nv::target::sm_87
+#  define _NV_TARGET_VAL_SM_89 nv::target::sm_89
+#  define _NV_TARGET_VAL_SM_90 nv::target::sm_90
+
+#  define _NV_TARGET___NV_IS_HOST nv::target::is_host
+#  define _NV_TARGET___NV_IS_DEVICE nv::target::is_device
+
+#  define _NV_TARGET___NV_ANY_TARGET (nv::target::any_target)
+#  define _NV_TARGET___NV_NO_TARGET (nv::target::no_target)
+
+#  if defined(NV_TARGET_SM_INTEGER_LIST)
+#    define NV_TARGET_MINIMUM_SM_SELECTOR _NV_FIRST_ARG(NV_TARGET_SM_SELECTOR_LIST)
+#    define NV_TARGET_MINIMUM_SM_INTEGER _NV_FIRST_ARG(NV_TARGET_SM_INTEGER_LIST)
+#    define __CUDA_MINIMUM_ARCH__ _NV_CONCAT_EVAL(_NV_FIRST_ARG(NV_TARGET_SM_INTEGER_LIST), 0)
+#  endif
+
+#  define _NV_TARGET_PROVIDES(q)   nv::target::provides(q)
+#  define _NV_TARGET_IS_EXACTLY(q) nv::target::is_exactly(q)
+
+#elif defined(_NV_COMPILER_NVCC) || defined (_NV_COMPILER_CLANG_CUDA)
+
+#  define _NV_TARGET_VAL_SM_35 350
+#  define _NV_TARGET_VAL_SM_37 370
+#  define _NV_TARGET_VAL_SM_50 500
+#  define _NV_TARGET_VAL_SM_52 520
+#  define _NV_TARGET_VAL_SM_53 530
+#  define _NV_TARGET_VAL_SM_60 600
+#  define _NV_TARGET_VAL_SM_61 610
+#  define _NV_TARGET_VAL_SM_62 620
+#  define _NV_TARGET_VAL_SM_70 700
+#  define _NV_TARGET_VAL_SM_72 720
+#  define _NV_TARGET_VAL_SM_75 750
+#  define _NV_TARGET_VAL_SM_80 800
+#  define _NV_TARGET_VAL_SM_86 860
+#  define _NV_TARGET_VAL_SM_87 870
+#  define _NV_TARGET_VAL_SM_89 890
+#  define _NV_TARGET_VAL_SM_90 900
+
+#  if defined(__CUDA_ARCH__)
+#    define _NV_TARGET_VAL __CUDA_ARCH__
+#    define NV_TARGET_MINIMUM_SM_SELECTOR _NV_CONCAT_EVAL(_NV_TARGET_ARCH_TO_SELECTOR_, __CUDA_ARCH__)
+#    define NV_TARGET_MINIMUM_SM_INTEGER _NV_CONCAT_EVAL(_NV_TARGET_ARCH_TO_SM_, __CUDA_ARCH__)
+#    define __CUDA_MINIMUM_ARCH__ __CUDA_ARCH__
+#  endif
+
+#  if defined(__CUDA_ARCH__)
+#    define _NV_TARGET_IS_HOST   0
+#    define _NV_TARGET_IS_DEVICE 1
+#  else
+#    define _NV_TARGET_IS_HOST   1
+#    define _NV_TARGET_IS_DEVICE 0
+#  endif
+
+#  if defined(_NV_TARGET_VAL)
+#    define _NV_DEVICE_CHECK(q) (q)
+#  else
+#    define _NV_DEVICE_CHECK(q) (0)
+#  endif
+
+#  define _NV_TARGET_PROVIDES(q)   _NV_DEVICE_CHECK(_NV_TARGET_VAL >= q)
+#  define _NV_TARGET_IS_EXACTLY(q) _NV_DEVICE_CHECK(_NV_TARGET_VAL == q)
+
+// NVCC/NVCXX not being used, only host dispatches allowed
+#else
+
+#  define _NV_COMPILER_NVCC
+
+#  define _NV_TARGET_VAL_SM_35 350
+#  define _NV_TARGET_VAL_SM_37 370
+#  define _NV_TARGET_VAL_SM_50 500
+#  define _NV_TARGET_VAL_SM_52 520
+#  define _NV_TARGET_VAL_SM_53 530
+#  define _NV_TARGET_VAL_SM_60 600
+#  define _NV_TARGET_VAL_SM_61 610
+#  define _NV_TARGET_VAL_SM_62 620
+#  define _NV_TARGET_VAL_SM_70 700
+#  define _NV_TARGET_VAL_SM_72 720
+#  define _NV_TARGET_VAL_SM_75 750
+#  define _NV_TARGET_VAL_SM_80 800
+#  define _NV_TARGET_VAL_SM_86 860
+#  define _NV_TARGET_VAL_SM_87 870
+#  define _NV_TARGET_VAL_SM_89 890
+#  define _NV_TARGET_VAL_SM_90 900
+
+#  define _NV_TARGET_VAL 0
+
+#  define _NV_TARGET_IS_HOST   1
+#  define _NV_TARGET_IS_DEVICE 0
+
+#  define _NV_DEVICE_CHECK(q) (false)
+
+#  define _NV_TARGET_PROVIDES(q)   _NV_DEVICE_CHECK(_NV_TARGET_VAL >= q)
+#  define _NV_TARGET_IS_EXACTLY(q) _NV_DEVICE_CHECK(_NV_TARGET_VAL == q)
+
+#endif
+
+#define _NV_TARGET___NV_PROVIDES_SM_35 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_35))
+#define _NV_TARGET___NV_PROVIDES_SM_37 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_37))
+#define _NV_TARGET___NV_PROVIDES_SM_50 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_50))
+#define _NV_TARGET___NV_PROVIDES_SM_52 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_52))
+#define _NV_TARGET___NV_PROVIDES_SM_53 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_53))
+#define _NV_TARGET___NV_PROVIDES_SM_60 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_60))
+#define _NV_TARGET___NV_PROVIDES_SM_61 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_61))
+#define _NV_TARGET___NV_PROVIDES_SM_62 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_62))
+#define _NV_TARGET___NV_PROVIDES_SM_70 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_70))
+#define _NV_TARGET___NV_PROVIDES_SM_72 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_72))
+#define _NV_TARGET___NV_PROVIDES_SM_75 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_75))
+#define _NV_TARGET___NV_PROVIDES_SM_80 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_80))
+#define _NV_TARGET___NV_PROVIDES_SM_86 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_86))
+#define _NV_TARGET___NV_PROVIDES_SM_87 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_87))
+#define _NV_TARGET___NV_PROVIDES_SM_89 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_89))
+#define _NV_TARGET___NV_PROVIDES_SM_90 (_NV_TARGET_PROVIDES(_NV_TARGET_VAL_SM_90))
+
+#define _NV_TARGET___NV_IS_EXACTLY_SM_35 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_35))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_37 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_37))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_50 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_50))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_52 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_52))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_53 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_53))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_60 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_60))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_61 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_61))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_62 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_62))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_70 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_70))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_72 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_72))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_75 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_75))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_80 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_80))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_86 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_86))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_87 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_87))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_89 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_89))
+#define _NV_TARGET___NV_IS_EXACTLY_SM_90 (_NV_TARGET_IS_EXACTLY(_NV_TARGET_VAL_SM_90))
+
+#define NV_PROVIDES_SM_35   __NV_PROVIDES_SM_35
+#define NV_PROVIDES_SM_37   __NV_PROVIDES_SM_37
+#define NV_PROVIDES_SM_50   __NV_PROVIDES_SM_50
+#define NV_PROVIDES_SM_52   __NV_PROVIDES_SM_52
+#define NV_PROVIDES_SM_53   __NV_PROVIDES_SM_53
+#define NV_PROVIDES_SM_60   __NV_PROVIDES_SM_60
+#define NV_PROVIDES_SM_61   __NV_PROVIDES_SM_61
+#define NV_PROVIDES_SM_62   __NV_PROVIDES_SM_62
+#define NV_PROVIDES_SM_70   __NV_PROVIDES_SM_70
+#define NV_PROVIDES_SM_72   __NV_PROVIDES_SM_72
+#define NV_PROVIDES_SM_75   __NV_PROVIDES_SM_75
+#define NV_PROVIDES_SM_80   __NV_PROVIDES_SM_80
+#define NV_PROVIDES_SM_86   __NV_PROVIDES_SM_86
+#define NV_PROVIDES_SM_87   __NV_PROVIDES_SM_87
+#define NV_PROVIDES_SM_89   __NV_PROVIDES_SM_89
+#define NV_PROVIDES_SM_90   __NV_PROVIDES_SM_90
+
+#define NV_IS_EXACTLY_SM_35 __NV_IS_EXACTLY_SM_35
+#define NV_IS_EXACTLY_SM_37 __NV_IS_EXACTLY_SM_37
+#define NV_IS_EXACTLY_SM_50 __NV_IS_EXACTLY_SM_50
+#define NV_IS_EXACTLY_SM_52 __NV_IS_EXACTLY_SM_52
+#define NV_IS_EXACTLY_SM_53 __NV_IS_EXACTLY_SM_53
+#define NV_IS_EXACTLY_SM_60 __NV_IS_EXACTLY_SM_60
+#define NV_IS_EXACTLY_SM_61 __NV_IS_EXACTLY_SM_61
+#define NV_IS_EXACTLY_SM_62 __NV_IS_EXACTLY_SM_62
+#define NV_IS_EXACTLY_SM_70 __NV_IS_EXACTLY_SM_70
+#define NV_IS_EXACTLY_SM_72 __NV_IS_EXACTLY_SM_72
+#define NV_IS_EXACTLY_SM_75 __NV_IS_EXACTLY_SM_75
+#define NV_IS_EXACTLY_SM_80 __NV_IS_EXACTLY_SM_80
+#define NV_IS_EXACTLY_SM_86 __NV_IS_EXACTLY_SM_86
+#define NV_IS_EXACTLY_SM_87 __NV_IS_EXACTLY_SM_87
+#define NV_IS_EXACTLY_SM_89 __NV_IS_EXACTLY_SM_89
+#define NV_IS_EXACTLY_SM_90 __NV_IS_EXACTLY_SM_90
+
+#define NV_IS_HOST         __NV_IS_HOST
+#define NV_IS_DEVICE       __NV_IS_DEVICE
+
+#define NV_ANY_TARGET      __NV_ANY_TARGET
+#define NV_NO_TARGET       __NV_NO_TARGET
+
+// Platform invoke mechanisms
+#if defined(_NV_COMPILER_NVCXX) && defined(_NVHPC_CUDA)
+
+#  define _NV_ARCH_COND(q) (_NV_TARGET_##q)
+
+#  define _NV_BLOCK_EXPAND(...) _NV_REMOVE_PAREN(__VA_ARGS__)
+
+#  define _NV_TARGET_IF(cond, t, ...) \
+    (if target _NV_ARCH_COND(cond) {    \
+      _NV_BLOCK_EXPAND(t)        \
+    } else { _NV_BLOCK_EXPAND(__VA_ARGS__) })
+
+#elif defined(_NV_COMPILER_NVCC) || defined (_NV_COMPILER_CLANG_CUDA)
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_35)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_35 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_35 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_37)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_37 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_37 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_50)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_50 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_50 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_52)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_52 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_52 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_53)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_53 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_53 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_60)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_60 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_60 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_61)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_61 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_61 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_62)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_62 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_62 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_70)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_70 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_70 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_72)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_72 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_72 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_75)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_75 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_75 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_80)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_80 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_80 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_86)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_86 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_86 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_87)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_87 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_87 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_89)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_89 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_89 0
+#  endif
+
+#  if (_NV_TARGET___NV_IS_EXACTLY_SM_90)
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_90 1
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_EXACTLY_SM_90 0
+#  endif
+
+#  if (_NV_TARGET_IS_HOST)
+#    define _NV_TARGET_BOOL___NV_IS_HOST   1
+#    define _NV_TARGET_BOOL___NV_IS_DEVICE 0
+#  else
+#    define _NV_TARGET_BOOL___NV_IS_HOST   0
+#    define _NV_TARGET_BOOL___NV_IS_DEVICE 1
+#  endif
+
+#  define _NV_TARGET_BOOL___NV_ANY_TARGET 1
+#  define _NV_TARGET_BOOL___NV_NO_TARGET 0
+
+// NVCC Greater than stuff
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_35)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_35 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_35 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_37)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_37 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_37 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_50)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_50 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_50 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_52)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_52 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_52 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_53)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_53 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_53 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_60)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_60 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_60 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_61)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_61 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_61 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_62)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_62 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_62 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_70)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_70 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_70 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_72)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_72 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_72 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_75)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_75 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_75 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_80)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_80 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_80 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_86)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_86 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_86 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_87)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_87 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_87 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_89)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_89 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_89 0
+#  endif
+
+#  if (_NV_TARGET___NV_PROVIDES_SM_90)
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_90 1
+#  else
+#    define _NV_TARGET_BOOL___NV_PROVIDES_SM_90 0
+#  endif
+
+#  define _NV_ARCH_COND_CAT1(cond) _NV_TARGET_BOOL_##cond
+#  define _NV_ARCH_COND_CAT(cond) _NV_EVAL(_NV_ARCH_COND_CAT1(cond))
+
+#    define _NV_TARGET_EMPTY_PARAM ;
+
+#  if defined(_NV_TARGET_CPP11)
+
+#    define _NV_BLOCK_EXPAND(...) { _NV_REMOVE_PAREN(__VA_ARGS__) }
+#    define _NV_TARGET_IF(cond, t, ...) _NV_IF( _NV_ARCH_COND_CAT(cond), t, __VA_ARGS__)
+
+#  else // <C++11 fallback
+
+#    define _NV_BLOCK_EXPAND(x) { x }
+
+#    define _NV_TARGET_IF(cond, t)         _NV_IF(_NV_ARCH_COND_CAT(cond), t, _NV_TARGET_EMPTY_PARAM)
+#    define _NV_TARGET_IF_ELSE(cond, t, f) _NV_IF(_NV_ARCH_COND_CAT(cond), t, f)
+
+#  endif
+
+#endif // _NV_COMPILER_NVCC
+
+#if defined(_NV_TARGET_CPP11)
+
+#  define _NV_TARGET_DISPATCH_HANDLE0()
+#  define _NV_TARGET_DISPATCH_HANDLE2(q, fn)        _NV_TARGET_IF(q, fn)
+#  define _NV_TARGET_DISPATCH_HANDLE4(q, fn, ...)   _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE2(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE6(q, fn, ...)   _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE4(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE8(q, fn, ...)   _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE6(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE10(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE8(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE12(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE10(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE14(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE12(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE16(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE14(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE18(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE16(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE20(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE18(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE22(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE20(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE24(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE22(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE26(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE24(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE28(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE26(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE30(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE28(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE32(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE30(__VA_ARGS__))
+#  define _NV_TARGET_DISPATCH_HANDLE34(q, fn, ...)  _NV_TARGET_IF(q, fn, _NV_TARGET_DISPATCH_HANDLE32(__VA_ARGS__))
+
+#  define _NV_TARGET_DISPATCH(...) _NV_BLOCK_EXPAND(_NV_DISPATCH_N_ARY(_NV_TARGET_DISPATCH_HANDLE, __VA_ARGS__))
+
+// NV_IF_TARGET supports a false statement provided as a variadic macro
+#  define NV_IF_TARGET(cond, ...)    _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, __VA_ARGS__))
+#  define NV_IF_ELSE_TARGET(cond, t, f) _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, t, f))
+#  define NV_DISPATCH_TARGET(...)       _NV_TARGET_DISPATCH(__VA_ARGS__)
+
+#else // <C++11 fallback
+
+// NV_IF_TARGET does not support a fallback false statement in C++03 or C dialects
+#  define NV_IF_TARGET(cond, t)         _NV_BLOCK_EXPAND(_NV_TARGET_IF(cond, t))
+#  define NV_IF_ELSE_TARGET(cond, t, f) _NV_BLOCK_EXPAND(_NV_TARGET_IF_ELSE(cond, t, f))
+
+#endif
+
+#endif // _NV__TARGET_MACROS
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/target b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/target
new file mode 100644
index 0000000000000000000000000000000000000000..f9e7d48c16f7bdbc9423f21961731a4eb43fa415
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nv/target
@@ -0,0 +1,203 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// This header contains a preview of a portability system that enables
+// CUDA C++ development with NVC++, NVCC, and supported host compilers.
+// These interfaces are not guaranteed to be stable.
+
+#ifndef __NV_TARGET_H
+#define __NV_TARGET_H
+
+#if defined(__NVCC__) || defined(__CUDACC_RTC__)
+#  define _NV_COMPILER_NVCC
+#elif defined(__NVCOMPILER) && __cplusplus >= 201103L
+#  define _NV_COMPILER_NVCXX
+#elif defined(__clang__) && defined(__CUDA__) && defined(__CUDA_ARCH__)
+// clang compiling CUDA code, device mode.
+#  define _NV_COMPILER_CLANG_CUDA
+#endif
+
+#if (!defined(__ibmxl__)) && \
+    ((defined(__cplusplus) && __cplusplus >= 201103L) || \
+     (defined(_MSC_VER) && _MSVC_LANG >= 201103L))
+#  define _NV_TARGET_CPP11
+#endif
+
+
+// Hide `if target` support from NVRTC
+#if defined(_NV_TARGET_CPP11) && !defined(__CUDACC_RTC__)
+
+#if defined(_NV_COMPILER_NVCXX)
+#  define _NV_BITSET_ATTRIBUTE [[nv::__target_bitset]]
+#else
+#  define _NV_BITSET_ATTRIBUTE
+#endif
+
+namespace nv {
+  namespace target {
+    namespace detail {
+
+      typedef unsigned long long base_int_t;
+
+      // No host specialization
+      constexpr base_int_t all_hosts = 1;
+
+      // NVIDIA GPUs
+      constexpr base_int_t sm_35_bit = 1 << 1;
+      constexpr base_int_t sm_37_bit = 1 << 2;
+      constexpr base_int_t sm_50_bit = 1 << 3;
+      constexpr base_int_t sm_52_bit = 1 << 4;
+      constexpr base_int_t sm_53_bit = 1 << 5;
+      constexpr base_int_t sm_60_bit = 1 << 6;
+      constexpr base_int_t sm_61_bit = 1 << 7;
+      constexpr base_int_t sm_62_bit = 1 << 8;
+      constexpr base_int_t sm_70_bit = 1 << 9;
+      constexpr base_int_t sm_72_bit = 1 << 10;
+      constexpr base_int_t sm_75_bit = 1 << 11;
+      constexpr base_int_t sm_80_bit = 1 << 12;
+      constexpr base_int_t sm_86_bit = 1 << 13;
+      constexpr base_int_t sm_87_bit = 1 << 14;
+      constexpr base_int_t sm_89_bit = 1 << 15;
+      constexpr base_int_t sm_90_bit = 1 << 16;
+      constexpr base_int_t all_devices =
+          sm_35_bit | sm_37_bit |
+          sm_50_bit | sm_52_bit | sm_53_bit |
+          sm_60_bit | sm_61_bit | sm_62_bit |
+          sm_70_bit | sm_72_bit | sm_75_bit |
+          sm_80_bit | sm_86_bit | sm_87_bit |
+          sm_89_bit | sm_90_bit;
+
+      // Store a set of targets as a set of bits
+      struct _NV_BITSET_ATTRIBUTE target_description {
+        base_int_t targets;
+
+        constexpr target_description(base_int_t a) : targets(a) { }
+      };
+
+      // The type of the user-visible names of the NVIDIA GPU targets
+      enum class sm_selector : base_int_t {
+        sm_35 = 35, sm_37 = 37,
+        sm_50 = 50, sm_52 = 52, sm_53 = 53,
+        sm_60 = 60, sm_61 = 61, sm_62 = 62,
+        sm_70 = 70, sm_72 = 72, sm_75 = 75,
+        sm_80 = 80, sm_86 = 86, sm_87 = 87,
+        sm_89 = 89, sm_90 = 90,
+      };
+
+      constexpr base_int_t toint(sm_selector a) {
+        return static_cast<base_int_t>(a);
+      }
+
+      constexpr base_int_t bitexact(sm_selector a) {
+        return toint(a) == 35 ? sm_35_bit :
+               toint(a) == 37 ? sm_37_bit :
+               toint(a) == 50 ? sm_50_bit :
+               toint(a) == 52 ? sm_52_bit :
+               toint(a) == 53 ? sm_53_bit :
+               toint(a) == 60 ? sm_60_bit :
+               toint(a) == 61 ? sm_61_bit :
+               toint(a) == 62 ? sm_62_bit :
+               toint(a) == 70 ? sm_70_bit :
+               toint(a) == 72 ? sm_72_bit :
+               toint(a) == 75 ? sm_75_bit :
+               toint(a) == 80 ? sm_80_bit :
+               toint(a) == 86 ? sm_86_bit :
+               toint(a) == 87 ? sm_87_bit :
+               toint(a) == 89 ? sm_89_bit :
+               toint(a) == 90 ? sm_90_bit : 0;
+      }
+
+      constexpr base_int_t bitrounddown(sm_selector a) {
+        return toint(a) >= 90 ? sm_90_bit :
+               toint(a) >= 89 ? sm_89_bit :
+               toint(a) >= 87 ? sm_87_bit :
+               toint(a) >= 86 ? sm_86_bit :
+               toint(a) >= 80 ? sm_80_bit :
+               toint(a) >= 75 ? sm_75_bit :
+               toint(a) >= 72 ? sm_72_bit :
+               toint(a) >= 70 ? sm_70_bit :
+               toint(a) >= 62 ? sm_62_bit :
+               toint(a) >= 61 ? sm_61_bit :
+               toint(a) >= 60 ? sm_60_bit :
+               toint(a) >= 53 ? sm_53_bit :
+               toint(a) >= 52 ? sm_52_bit :
+               toint(a) >= 50 ? sm_50_bit :
+               toint(a) >= 37 ? sm_37_bit :
+               toint(a) >= 35 ? sm_35_bit : 0;
+      }
+
+      // Public API for NVIDIA GPUs
+
+      constexpr target_description is_exactly(sm_selector a) {
+        return target_description(bitexact(a));
+      }
+
+      constexpr target_description provides(sm_selector a) {
+        return target_description(~(bitrounddown(a) - 1) & all_devices);
+      }
+
+      // Boolean operations on target sets
+
+      constexpr target_description operator&&(target_description a,
+                                              target_description b) {
+        return target_description(a.targets & b.targets);
+      }
+
+      constexpr target_description operator||(target_description a,
+                                              target_description b) {
+        return target_description(a.targets | b.targets);
+      }
+
+      constexpr target_description operator!(target_description a) {
+        return target_description(~a.targets & (all_devices | all_hosts));
+      }
+    }
+
+    using detail::target_description;
+    using detail::sm_selector;
+
+    // The predicates for basic host/device selection
+    constexpr target_description is_host =
+      target_description(detail::all_hosts);
+    constexpr target_description is_device =
+      target_description(detail::all_devices);
+    constexpr target_description any_target =
+      target_description(detail::all_hosts | detail::all_devices);
+    constexpr target_description no_target =
+      target_description(0);
+
+    // The public names for NVIDIA GPU architectures
+    constexpr sm_selector sm_35 = sm_selector::sm_35;
+    constexpr sm_selector sm_37 = sm_selector::sm_37;
+    constexpr sm_selector sm_50 = sm_selector::sm_50;
+    constexpr sm_selector sm_52 = sm_selector::sm_52;
+    constexpr sm_selector sm_53 = sm_selector::sm_53;
+    constexpr sm_selector sm_60 = sm_selector::sm_60;
+    constexpr sm_selector sm_61 = sm_selector::sm_61;
+    constexpr sm_selector sm_62 = sm_selector::sm_62;
+    constexpr sm_selector sm_70 = sm_selector::sm_70;
+    constexpr sm_selector sm_72 = sm_selector::sm_72;
+    constexpr sm_selector sm_75 = sm_selector::sm_75;
+    constexpr sm_selector sm_80 = sm_selector::sm_80;
+    constexpr sm_selector sm_86 = sm_selector::sm_86;
+    constexpr sm_selector sm_87 = sm_selector::sm_87;
+    constexpr sm_selector sm_89 = sm_selector::sm_89;
+    constexpr sm_selector sm_90 = sm_selector::sm_90;
+
+    using detail::is_exactly;
+    using detail::provides;
+  }
+}
+
+#endif // C++11  && !defined(__CUDACC_RTC__)
+
+#include "detail/__target_macros"
+
+#endif // __NV_TARGET_H
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExt.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExt.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fab7d874340fad50d63d80b6b68f678ec243191
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExt.h
@@ -0,0 +1,1499 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+/** \file nvToolsExt.h
+ */
+
+/* ========================================================================= */
+/** \mainpage
+ * \tableofcontents
+ * \section INTRODUCTION Introduction
+ *
+ * The NVIDIA Tools Extension library is a set of functions that a
+ * developer can use to provide additional information to tools.
+ * The additional information is used by the tool to improve
+ * analysis and visualization of data.
+ *
+ * The library introduces close to zero overhead if no tool is
+ * attached to the application.  The overhead when a tool is
+ * attached is specific to the tool.
+ *
+ * \section INITIALIZATION_SECTION Initialization
+ *
+ * Typically the tool's library that plugs into NVTX is indirectly 
+ * loaded via enviromental properties that are platform specific. 
+ * For some platform or special cases, the user may be required 
+ * to instead explicity initialize instead though.   This can also
+ * be helpful to control when the API loads a tool's library instead
+ * of what would typically be the first function call to emit info.
+ * For these rare case, see \ref INITIALIZATION for additional information.
+ *
+ * \section MARKERS_AND_RANGES Markers and Ranges
+ *
+ * Markers and ranges are used to describe events at a specific time (markers)
+ * or over a time span (ranges) during the execution of the application
+ * respectively. 
+ *
+ * \subsection MARKERS Markers
+ * 
+ * Markers denote specific moments in time.
+ * 
+ * 
+ * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on
+ * how to specify the domain.
+ * 
+ * \subsection THREAD_RANGES Thread Ranges
+ *
+ * Thread ranges denote nested time ranges. Nesting is maintained per thread
+ * per domain and does not require any additional correlation mechanism. The
+ * duration of a thread range is defined by the corresponding pair of
+ * nvtxRangePush* to nvtxRangePop API calls.
+ *
+ * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on
+ * how to specify the domain.
+ *
+ * \subsection PROCESS_RANGES Process Ranges
+ *
+ * Process ranges denote a time span that can expose arbitrary concurrency, as 
+ * opposed to thread ranges that only support nesting. In addition the range
+ * start event can happen on a different thread than the end marker. For the 
+ * correlation of a start/end pair an unique correlation ID is used that is
+ * returned from the start API call and needs to be passed into the end API
+ * call.
+ *
+ * \subsection EVENT_ATTRIBUTES Event Attributes
+ *
+ * \ref MARKERS_AND_RANGES can be annotated with various attributes to provide
+ * additional information for an event or to guide the tool's visualization of
+ * the data. Each of the attributes is optional and if left unused the
+ * attributes fall back to a default value. The attributes include:
+ * - color
+ * - category
+ *
+ * To specify any attribute other than the text message, the \ref
+ * EVENT_ATTRIBUTE_STRUCTURE "Event Attribute Structure" must be used.
+ *
+ * \section DOMAINS Domains
+ *
+ * Domains enable developers to scope annotations. By default all events and
+ * annotations are in the default domain. Additional domains can be registered.
+ * This allows developers to scope markers, ranges, and resources names to
+ * avoid conflicts.
+ *
+ * The function ::nvtxDomainCreateA or ::nvtxDomainCreateW is used to create
+ * a named domain.
+ * 
+ * Each domain maintains its own
+ * - categories
+ * - thread range stacks
+ * - registered strings
+ *
+ * The function ::nvtxDomainDestroy marks the end of the domain. Destroying 
+ * a domain unregisters and destroys all objects associated with it such as 
+ * registered strings, resource objects, named categories, and started ranges. 
+ *
+ * \section RESOURCE_NAMING Resource Naming
+ *
+ * This section covers calls that allow to annotate objects with user-provided
+ * names in order to allow for a better analysis of complex trace data. All of
+ * the functions take the handle or the ID of the object to name and the name.
+ * The functions can be called multiple times during the execution of an
+ * application, however, in that case it is implementation dependent which
+ * name will be reported by the tool.
+ * 
+ * \subsection CATEGORY_NAMING Category Naming
+ *
+ * Some function in this library support associating an integer category 
+ * to enable filtering and sorting.  The category naming functions allow 
+ * the application to associate a user friendly name with the integer 
+ * category.  Support for domains have been added in NVTX_VERSION_2 to 
+ * avoid collisions when domains are developed independantly. 
+ *
+ * \subsection RESOURCE_OBJECTS Resource Objects
+ *
+ * Resource objects are a generic mechanism for attaching data to an application 
+ * resource.  The identifier field makes the association to a pointer or handle, 
+ * while the type field helps provide deeper understanding of the identifier as 
+ * well as enabling differentiation in cases where handles generated by different
+ * APIs may collide.  The resource object may also have an associated message to
+ * associate with the application resource, enabling further annotation of this 
+ * object and how it is used.
+ * 
+ * The resource object was introduced in NVTX_VERSION_2 to supersede existing naming
+ * functions and allow the application resource identified by those functions to be
+ * associated to a domain.  The other naming functions are still supported for backward
+ * compatibility but will be associated only to the default domain.
+ *
+ * \subsection RESOURCE_NAMING_OS Resource Naming
+ * 
+ * Some operating system resources creation APIs do not support providing a user friendly 
+ * name, such as some OS thread creation APIs.  This API support resource naming though 
+ * both through resource objects and functions following the pattern 
+ * nvtxName[RESOURCE_TYPE][A|W](identifier, name).  Resource objects introduced in NVTX_VERSION 2 
+ * supersede the other functions with a a more general method of assigning names to OS resources,
+ * along with associating them to domains too.  The older nvtxName* functions are only associated 
+ * with the default domain.
+ * \section EXTENSIONS Optional Extensions
+ * Optional extensions will either appear within the existing sections the extend or appear 
+ * in the "Related Pages" when they introduce new concepts.
+ */
+
+ /**
+ * Tools Extension API version
+ */
+#if defined(NVTX_VERSION) && NVTX_VERSION < 3
+#error "Trying to #include NVTX version 3 in a source file where an older NVTX version has already been included.  If you are not directly using NVTX (the NVIDIA Tools Extension library), you are getting this error because libraries you are using have included different versions of NVTX.  Suggested solutions are: (1) reorder #includes so the newest NVTX version is included first, (2) avoid using the conflicting libraries in the same .c/.cpp file, or (3) update the library using the older NVTX version to use the newer version instead."
+#endif
+
+/* Header guard */
+#if !defined(NVTX_VERSION)
+#define NVTX_VERSION 3
+
+#if defined(_MSC_VER)
+#define NVTX_API __stdcall
+#define NVTX_INLINE_STATIC __inline static
+#else /*defined(__GNUC__)*/
+#define NVTX_API
+#define NVTX_INLINE_STATIC inline static
+#endif /* Platform */
+
+#if defined(NVTX_NO_IMPL)
+/* When omitting implementation, avoid declaring functions inline */
+/* without definitions, since this causes compiler warnings. */
+#define NVTX_DECLSPEC
+#elif defined(NVTX_EXPORT_API)
+/* Allow overriding definition of NVTX_DECLSPEC when exporting API. */
+/* Default is empty, meaning non-inline with external linkage. */
+#if !defined(NVTX_DECLSPEC)
+#define NVTX_DECLSPEC
+#endif
+#else
+/* Normal NVTX usage defines the NVTX API inline with static */
+/* (internal) linkage. */
+#define NVTX_DECLSPEC NVTX_INLINE_STATIC
+#endif
+
+#include "nvtxDetail/nvtxLinkOnce.h"
+
+#define NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION) NAME##_v##VERSION
+#define NVTX_VERSIONED_IDENTIFIER_L2(NAME, VERSION) NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION)
+#define NVTX_VERSIONED_IDENTIFIER(NAME) NVTX_VERSIONED_IDENTIFIER_L2(NAME, NVTX_VERSION)
+
+/**
+ * The nvToolsExt library depends on stdint.h.  If the build tool chain in use
+ * does not include stdint.h then define NVTX_STDINT_TYPES_ALREADY_DEFINED
+ * and define the following types:
+ * <ul>
+ *   <li>uint8_t
+ *   <li>int8_t
+ *   <li>uint16_t
+ *   <li>int16_t
+ *   <li>uint32_t
+ *   <li>int32_t
+ *   <li>uint64_t
+ *   <li>int64_t
+ *   <li>uintptr_t
+ *   <li>intptr_t
+ * </ul>
+ * #define NVTX_STDINT_TYPES_ALREADY_DEFINED if you are using your own header file.
+ */
+#ifndef NVTX_STDINT_TYPES_ALREADY_DEFINED
+#include <stdint.h>
+#endif
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** 
+* Result Codes
+*/
+
+#define NVTX_SUCCESS 0
+#define NVTX_FAIL 1
+#define NVTX_ERR_INIT_LOAD_PROPERTY 2
+#define NVTX_ERR_INIT_ACCESS_LIBRARY 3
+#define NVTX_ERR_INIT_LOAD_LIBRARY 4
+#define NVTX_ERR_INIT_MISSING_LIBRARY_ENTRY_POINT 5
+#define NVTX_ERR_INIT_FAILED_LIBRARY_ENTRY_POINT 6
+#define NVTX_ERR_NO_INJECTION_LIBRARY_AVAILABLE 7
+
+/**
+ * Size of the nvtxEventAttributes_t structure.
+ */
+#define NVTX_EVENT_ATTRIB_STRUCT_SIZE ( (uint16_t)( sizeof(nvtxEventAttributes_t) ) )
+
+#define NVTX_NO_PUSH_POP_TRACKING ((int)-2)
+
+typedef uint64_t nvtxRangeId_t;
+
+/* Forward declaration of opaque domain registration structure */
+struct nvtxDomainRegistration_st;
+typedef struct nvtxDomainRegistration_st nvtxDomainRegistration;
+
+/* \brief Domain Handle Structure.
+* \anchor DOMAIN_HANDLE_STRUCTURE
+*
+* This structure is opaque to the user and is used as a handle to reference
+* a domain.  This type is returned from tools when using the NVTX API to
+* create a domain.
+*
+*/
+typedef nvtxDomainRegistration* nvtxDomainHandle_t;
+
+/* Forward declaration of opaque string registration structure */
+struct nvtxStringRegistration_st;
+typedef struct nvtxStringRegistration_st nvtxStringRegistration;
+
+/* \brief Registered String Handle Structure.
+* \anchor REGISTERED_STRING_HANDLE_STRUCTURE
+*
+* This structure is opaque to the user and is used as a handle to reference
+* a registered string.  This type is returned from tools when using the NVTX
+* API to create a registered string.
+*
+*/
+typedef nvtxStringRegistration* nvtxStringHandle_t;
+
+/* ========================================================================= */
+/** \defgroup GENERAL General
+ * @{
+ */
+
+/** ---------------------------------------------------------------------------
+ * Color Types
+ * ------------------------------------------------------------------------- */
+typedef enum nvtxColorType_t
+{
+    NVTX_COLOR_UNKNOWN  = 0,                 /**< Color attribute is unused. */
+    NVTX_COLOR_ARGB     = 1                  /**< An ARGB color is provided. */
+} nvtxColorType_t;
+
+/** ---------------------------------------------------------------------------
+ * Message Types
+ * ------------------------------------------------------------------------- */
+typedef enum nvtxMessageType_t
+{
+    NVTX_MESSAGE_UNKNOWN          = 0,    /**< Message payload is unused. */
+    NVTX_MESSAGE_TYPE_ASCII       = 1,    /**< A character sequence is used as payload. */
+    NVTX_MESSAGE_TYPE_UNICODE     = 2,     /**< A wide character sequence is used as payload. */
+    /* NVTX_VERSION_2 */
+    NVTX_MESSAGE_TYPE_REGISTERED  = 3,    /**< A unique string handle that was registered
+                                                with \ref nvtxDomainRegisterStringA() or 
+                                                \ref nvtxDomainRegisterStringW(). */
+} nvtxMessageType_t;
+
+typedef union nvtxMessageValue_t
+{
+    const char* ascii;
+    const wchar_t* unicode;
+    /* NVTX_VERSION_2 */
+    nvtxStringHandle_t registered;
+} nvtxMessageValue_t;
+
+
+/** @} */ /*END defgroup*/
+/* ------------------------------------------------------------------------- */
+/** \brief Force initialization (optional)
+*
+* Force NVTX library to initialize.  The first call to any NVTX API function
+* will automatically initialize the entire API.  This can make the first call
+* much slower than subsequent calls.  In applications where the first call to
+* NVTX may be in a performance-critical section, calling nvtxInitialize before
+* any performance-critical sections will ensure NVTX initialization occurs at
+* an acceptable time.  Since nvtxInitialize takes no parameters and has no
+* expected behavior besides initialization, it is convenient to add a call to
+* nvtxInitialize in NVTX-instrumented applications that need to force earlier
+* initialization without changing any other code.  For example, if an app's
+* first NVTX call is nvtxDomainCreate, and it is difficult to move that call
+* earlier because the domain handle must be stored in an object only created
+* at that point, adding a call to nvtxInitialize at the top of main() will
+* ensure the later call to nvtxDomainCreate is as fast as possible.
+*
+* \version \NVTX_VERSION_3
+*
+* \param reserved - must be zero or NULL.
+*
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxInitialize(const void* reserved);
+/** @} */
+
+
+/** @} */ /*END defgroup*/
+
+/* ========================================================================= */
+/** \defgroup EVENT_ATTRIBUTES Event Attributes
+* @{
+*/
+
+/** ---------------------------------------------------------------------------
+* Payload Types
+* ------------------------------------------------------------------------- */
+typedef enum nvtxPayloadType_t
+{
+    NVTX_PAYLOAD_UNKNOWN = 0,   /**< Color payload is unused. */
+    NVTX_PAYLOAD_TYPE_UNSIGNED_INT64 = 1,   /**< A 64 bit unsigned integer value is used as payload. */
+    NVTX_PAYLOAD_TYPE_INT64 = 2,   /**< A 64 bit signed integer value is used as payload. */
+    NVTX_PAYLOAD_TYPE_DOUBLE = 3,   /**< A 64 bit floating point value is used as payload. */
+    /* NVTX_VERSION_2 */
+    NVTX_PAYLOAD_TYPE_UNSIGNED_INT32 = 4,   /**< A 32 bit floating point value is used as payload. */
+    NVTX_PAYLOAD_TYPE_INT32 = 5,   /**< A 32 bit floating point value is used as payload. */
+    NVTX_PAYLOAD_TYPE_FLOAT = 6    /**< A 32 bit floating point value is used as payload. */
+} nvtxPayloadType_t;
+
+/** \brief Event Attribute Structure.
+ * \anchor EVENT_ATTRIBUTE_STRUCTURE
+ *
+ * This structure is used to describe the attributes of an event. The layout of
+ * the structure is defined by a specific version of the tools extension
+ * library and can change between different versions of the Tools Extension
+ * library.
+ *
+ * \par Initializing the Attributes
+ *
+ * The caller should always perform the following three tasks when using
+ * attributes:
+ * <ul>
+ *    <li>Zero the structure
+ *    <li>Set the version field
+ *    <li>Set the size field
+ * </ul>
+ *
+ * Zeroing the structure sets all the event attributes types and values
+ * to the default value.
+ *
+ * The version and size field are used by the Tools Extension
+ * implementation to handle multiple versions of the attributes structure.
+ *
+ * It is recommended that the caller use one of the following to methods
+ * to initialize the event attributes structure:
+ *
+ * \par Method 1: Initializing nvtxEventAttributes for future compatibility
+ * \code
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * eventAttrib.version = NVTX_VERSION;
+ * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+ * \endcode
+ *
+ * \par Method 2: Initializing nvtxEventAttributes for a specific version
+ * \code
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * eventAttrib.version = 1;
+ * eventAttrib.size = (uint16_t)(sizeof(nvtxEventAttributes_v1));
+ * \endcode
+ *
+ * If the caller uses Method 1 it is critical that the entire binary
+ * layout of the structure be configured to 0 so that all fields
+ * are initialized to the default value.
+ *
+ * The caller should either use both NVTX_VERSION and
+ * NVTX_EVENT_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values
+ * and a versioned type (Method 2).  Using a mix of the two methods
+ * will likely cause either source level incompatibility or binary
+ * incompatibility in the future.
+ *
+ * \par Settings Attribute Types and Values
+ *
+ *
+ * \par Example:
+ * \code
+ * // Initialize
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * eventAttrib.version = NVTX_VERSION;
+ * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+ *
+ * // Configure the Attributes
+ * eventAttrib.colorType = NVTX_COLOR_ARGB;
+ * eventAttrib.color = 0xFF880000;
+ * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+ * eventAttrib.message.ascii = "Example";
+ * \endcode
+ *
+ * In the example the caller does not have to set the value of
+ * \ref ::nvtxEventAttributes_v2::category or
+ * \ref ::nvtxEventAttributes_v2::payload as these fields were set to
+ * the default value by {0}.
+ * \sa
+ * ::nvtxDomainMarkEx
+ * ::nvtxDomainRangeStartEx
+ * ::nvtxDomainRangePushEx
+ */
+typedef struct nvtxEventAttributes_v2
+{
+    /**
+    * \brief Version flag of the structure.
+    *
+    * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs
+    * supported in this header file. This can optionally be overridden to
+    * another version of the tools extension library.
+    */
+    uint16_t version;
+
+    /**
+    * \brief Size of the structure.
+    *
+    * Needs to be set to the size in bytes of the event attribute
+    * structure used to specify the event.
+    */
+    uint16_t size;
+
+    /**
+     * \brief ID of the category the event is assigned to.
+     *
+     * A category is a user-controlled ID that can be used to group
+     * events.  The tool may use category IDs to improve filtering or
+     * enable grouping of events in the same category. The functions
+     * \ref ::nvtxNameCategoryA or \ref ::nvtxNameCategoryW can be used
+     * to name a category.
+     *
+     * Default Value is 0
+     */
+    uint32_t category;
+
+    /** \brief Color type specified in this attribute structure.
+     *
+     * Defines the color format of the attribute structure's \ref COLOR_FIELD
+     * "color" field.
+     *
+     * Default Value is NVTX_COLOR_UNKNOWN
+     */
+    int32_t colorType;              /* nvtxColorType_t */
+
+    /** \brief Color assigned to this event. \anchor COLOR_FIELD
+     *
+     * The color that the tool should use to visualize the event.
+     */
+    uint32_t color;
+
+    /**
+     * \brief Payload type specified in this attribute structure.
+     *
+     * Defines the payload format of the attribute structure's \ref PAYLOAD_FIELD
+     * "payload" field.
+     *
+     * Default Value is NVTX_PAYLOAD_UNKNOWN
+     */
+    int32_t payloadType;            /* nvtxPayloadType_t */
+
+    int32_t reserved0;
+
+    /**
+     * \brief Payload assigned to this event. \anchor PAYLOAD_FIELD
+     *
+     * A numerical value that can be used to annotate an event. The tool could
+     * use the payload data to reconstruct graphs and diagrams.
+     */
+    union payload_t
+    {
+        uint64_t ullValue;
+        int64_t llValue;
+        double dValue;
+        /* NVTX_VERSION_2 */
+        uint32_t uiValue;
+        int32_t iValue;
+        float fValue;
+    } payload;
+
+    /** \brief Message type specified in this attribute structure.
+     *
+     * Defines the message format of the attribute structure's \ref MESSAGE_FIELD
+     * "message" field.
+     *
+     * Default Value is NVTX_MESSAGE_UNKNOWN
+     */
+    int32_t messageType;            /* nvtxMessageType_t */
+
+    /** \brief Message assigned to this attribute structure. \anchor MESSAGE_FIELD
+     *
+     * The text message that is attached to an event.
+     */
+    nvtxMessageValue_t message;
+
+} nvtxEventAttributes_v2;
+
+typedef struct nvtxEventAttributes_v2 nvtxEventAttributes_t;
+
+/** @} */ /*END defgroup*/
+/* ========================================================================= */
+/** \defgroup MARKERS_AND_RANGES Markers and Ranges
+ *
+ * See \ref MARKERS_AND_RANGES for more details
+ *
+ * @{
+ */
+
+/** \name Marker */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Marks an instantaneous event in the application.
+*
+* A marker can contain a text message or specify additional information
+* using the event attributes structure.  These attributes include a text
+* message, color, category, and a payload. Each of the attributes is optional
+* and can only be sent out using the \ref nvtxDomainMarkEx function.
+*
+* nvtxDomainMarkEx(NULL, event) is equivalent to calling
+* nvtxMarkEx(event).
+*
+* \param domain    - The domain of scoping the category.
+* \param eventAttrib - The event attribute structure defining the marker's
+* attribute types and attribute values.
+*
+* \sa
+* ::nvtxMarkEx
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxDomainMarkEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Marks an instantaneous event in the application.
+ *
+ * A marker can contain a text message or specify additional information
+ * using the event attributes structure.  These attributes include a text
+ * message, color, category, and a payload. Each of the attributes is optional
+ * and can only be sent out using the \ref nvtxMarkEx function.
+ * If \ref nvtxMarkA or \ref nvtxMarkW are used to specify the marker
+ * or if an attribute is unspecified then a default value will be used.
+ *
+ * \param eventAttrib - The event attribute structure defining the marker's
+ * attribute types and attribute values.
+ *
+ * \par Example:
+ * \code
+ * // zero the structure
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * // set the version and the size information
+ * eventAttrib.version = NVTX_VERSION;
+ * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+ * // configure the attributes.  0 is the default for all attributes.
+ * eventAttrib.colorType = NVTX_COLOR_ARGB;
+ * eventAttrib.color = 0xFF880000;
+ * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+ * eventAttrib.message.ascii = "Example nvtxMarkEx";
+ * nvtxMarkEx(&eventAttrib);
+ * \endcode
+ *
+ * \sa
+ * ::nvtxDomainMarkEx
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxMarkEx(const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Marks an instantaneous event in the application.
+ *
+ * A marker created using \ref nvtxMarkA or \ref nvtxMarkW contains only a
+ * text message.
+ *
+ * \param message     - The message associated to this marker event.
+ *
+ * \par Example:
+ * \code
+ * nvtxMarkA("Example nvtxMarkA");
+ * nvtxMarkW(L"Example nvtxMarkW");
+ * \endcode
+ *
+ * \sa
+ * ::nvtxDomainMarkEx
+ * ::nvtxMarkEx
+ *
+ * \version \NVTX_VERSION_0
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxMarkA(const char* message);
+NVTX_DECLSPEC void NVTX_API nvtxMarkW(const wchar_t* message);
+/** @} */
+
+
+/** \name Process Ranges */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a process range in a domain.
+*
+* \param domain    - The domain of scoping the category.
+* \param eventAttrib - The event attribute structure defining the range's
+* attribute types and attribute values.
+*
+* \return The unique ID used to correlate a pair of Start and End events.
+*
+* \remarks Ranges defined by Start/End can overlap.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain");
+* nvtxEventAttributes_t eventAttrib = {0};
+* eventAttrib.version = NVTX_VERSION;
+* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* eventAttrib.message.ascii = "my range";
+* nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(&eventAttrib);
+* // ...
+* nvtxDomainRangeEnd(rangeId);
+* \endcode
+*
+* \sa
+* ::nvtxDomainRangeEnd
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxDomainRangeStartEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a process range.
+ *
+ * \param eventAttrib - The event attribute structure defining the range's
+ * attribute types and attribute values.
+ *
+ * \return The unique ID used to correlate a pair of Start and End events.
+ *
+ * \remarks Ranges defined by Start/End can overlap.
+ *
+ * \par Example:
+ * \code
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * eventAttrib.version = NVTX_VERSION;
+ * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+ * eventAttrib.category = 3;
+ * eventAttrib.colorType = NVTX_COLOR_ARGB;
+ * eventAttrib.color = 0xFF0088FF;
+ * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+ * eventAttrib.message.ascii = "Example Range";
+ * nvtxRangeId_t rangeId = nvtxRangeStartEx(&eventAttrib);
+ * // ...
+ * nvtxRangeEnd(rangeId);
+ * \endcode
+ *
+ * \sa
+ * ::nvtxRangeEnd
+ * ::nvtxDomainRangeStartEx
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartEx(const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a process range.
+ *
+ * \param message     - The event message associated to this range event.
+ *
+ * \return The unique ID used to correlate a pair of Start and End events.
+ *
+ * \remarks Ranges defined by Start/End can overlap.
+ *
+ * \par Example:
+ * \code
+ * nvtxRangeId_t r1 = nvtxRangeStartA("Range 1");
+ * nvtxRangeId_t r2 = nvtxRangeStartW(L"Range 2");
+ * nvtxRangeEnd(r1);
+ * nvtxRangeEnd(r2);
+ * \endcode
+ *
+ * \sa
+ * ::nvtxRangeEnd
+ * ::nvtxRangeStartEx
+ * ::nvtxDomainRangeStartEx
+ *
+ * \version \NVTX_VERSION_0
+ * @{ */
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartA(const char* message);
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartW(const wchar_t* message);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Ends a process range.
+*
+* \param domain - The domain 
+* \param id - The correlation ID returned from a nvtxRangeStart call.
+*
+* \remarks This function is offered completeness but is an alias for ::nvtxRangeEnd. 
+* It does not need a domain param since that is associated iwth the range ID at ::nvtxDomainRangeStartEx
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain");
+* nvtxEventAttributes_t eventAttrib = {0};
+* eventAttrib.version = NVTX_VERSION;
+* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* eventAttrib.message.ascii = "my range";
+* nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(&eventAttrib);
+* // ...
+* nvtxDomainRangeEnd(rangeId);
+* \endcode
+*
+* \sa
+* ::nvtxDomainRangeStartEx
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxDomainRangeEnd(nvtxDomainHandle_t domain, nvtxRangeId_t id);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Ends a process range.
+ *
+ * \param id - The correlation ID returned from an nvtxRangeStart call.
+ *
+ * \sa
+ * ::nvtxDomainRangeStartEx
+ * ::nvtxRangeStartEx
+ * ::nvtxRangeStartA
+ * ::nvtxRangeStartW
+ *
+ * \version \NVTX_VERSION_0
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxRangeEnd(nvtxRangeId_t id);
+/** @} */
+
+/** \name Thread Ranges */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a nested thread range.
+*
+* \param domain    - The domain of scoping.
+* \param eventAttrib - The event attribute structure defining the range's
+* attribute types and attribute values.
+*
+* \return The 0 based level of range being started. This value is scoped to the domain.
+* If an error occurs, a negative value is returned.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
+* nvtxEventAttributes_t eventAttrib = {0};
+* eventAttrib.version = NVTX_VERSION;
+* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib.colorType = NVTX_COLOR_ARGB;
+* eventAttrib.color = 0xFFFF0000;
+* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* eventAttrib.message.ascii = "Level 0";
+* nvtxDomainRangePushEx(domain, &eventAttrib);
+*
+* // Re-use eventAttrib
+* eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE;
+* eventAttrib.message.unicode = L"Level 1";
+* nvtxDomainRangePushEx(domain, &eventAttrib);
+*
+* nvtxDomainRangePop(domain); //level 1
+* nvtxDomainRangePop(domain); //level 0
+* \endcode
+*
+* \sa
+* ::nvtxDomainRangePop
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC int NVTX_API nvtxDomainRangePushEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a nested thread range.
+ *
+ * \param eventAttrib - The event attribute structure defining the range's
+ * attribute types and attribute values.
+ *
+ * \return The 0 based level of range being started. This level is per domain.
+ * If an error occurs a negative value is returned.
+ *
+ * \par Example:
+ * \code
+ * nvtxEventAttributes_t eventAttrib = {0};
+ * eventAttrib.version = NVTX_VERSION;
+ * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+ * eventAttrib.colorType = NVTX_COLOR_ARGB;
+ * eventAttrib.color = 0xFFFF0000;
+ * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
+ * eventAttrib.message.ascii = "Level 0";
+ * nvtxRangePushEx(&eventAttrib);
+ *
+ * // Re-use eventAttrib
+ * eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE;
+ * eventAttrib.message.unicode = L"Level 1";
+ * nvtxRangePushEx(&eventAttrib);
+ *
+ * nvtxRangePop();
+ * nvtxRangePop();
+ * \endcode
+ *
+ * \sa
+ * ::nvtxDomainRangePushEx
+ * ::nvtxRangePop
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC int NVTX_API nvtxRangePushEx(const nvtxEventAttributes_t* eventAttrib);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Starts a nested thread range.
+ *
+ * \param message     - The event message associated to this range event.
+ *
+ * \return The 0 based level of range being started.  If an error occurs a
+ * negative value is returned.
+ *
+ * \par Example:
+ * \code
+ * nvtxRangePushA("Level 0");
+ * nvtxRangePushW(L"Level 1");
+ * nvtxRangePop();
+ * nvtxRangePop();
+ * \endcode
+ *
+ * \sa
+ * ::nvtxDomainRangePushEx
+ * ::nvtxRangePop
+ *
+ * \version \NVTX_VERSION_0
+ * @{ */
+NVTX_DECLSPEC int NVTX_API nvtxRangePushA(const char* message);
+NVTX_DECLSPEC int NVTX_API nvtxRangePushW(const wchar_t* message);
+/** @} */
+
+
+/* ------------------------------------------------------------------------- */
+/** \brief Ends a nested thread range.
+*
+* \return The level of the range being ended. If an error occurs a negative
+* value is returned on the current thread.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreate("example library");
+* nvtxDomainRangePushA(domain, "Level 0");
+* nvtxDomainRangePushW(domain, L"Level 1");
+* nvtxDomainRangePop(domain);
+* nvtxDomainRangePop(domain);
+* \endcode
+*
+* \sa
+* ::nvtxRangePushEx
+* ::nvtxRangePushA
+* ::nvtxRangePushW
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC int NVTX_API nvtxDomainRangePop(nvtxDomainHandle_t domain);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Ends a nested thread range.
+ *
+ * \return The level of the range being ended. If an error occurs a negative
+ * value is returned on the current thread.
+ *
+ * \par Example:
+ * \code
+ * nvtxRangePushA("Level 0");
+ * nvtxRangePushW(L"Level 1");
+ * nvtxRangePop();
+ * nvtxRangePop();
+ * \endcode
+ *
+ * \sa
+ * ::nvtxRangePushEx
+ * ::nvtxRangePushA
+ * ::nvtxRangePushW
+ *
+ * \version \NVTX_VERSION_0
+ * @{ */
+NVTX_DECLSPEC int NVTX_API nvtxRangePop(void);
+/** @} */
+
+
+/** @} */ /*END defgroup*/
+/* ========================================================================= */
+/** \defgroup RESOURCE_NAMING Resource Naming
+ *
+ * See \ref RESOURCE_NAMING for more details
+ *
+ * @{
+ */
+
+
+/*  ------------------------------------------------------------------------- */
+/** \name Functions for Generic Resource Naming*/
+/*  ------------------------------------------------------------------------- */
+
+/*  ------------------------------------------------------------------------- */
+/** \cond SHOW_HIDDEN
+* \brief Resource typing helpers.  
+*
+* Classes are used to make it easy to create a series of resource types 
+* per API without collisions 
+*/
+#define NVTX_RESOURCE_MAKE_TYPE(CLASS, INDEX) ((((uint32_t)(NVTX_RESOURCE_CLASS_ ## CLASS))<<16)|((uint32_t)(INDEX)))
+#define NVTX_RESOURCE_CLASS_GENERIC 1
+/** \endcond */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Generic resource type for when a resource class is not available.
+*
+* \sa
+* ::nvtxDomainResourceCreate
+*
+* \version \NVTX_VERSION_2
+*/
+typedef enum nvtxResourceGenericType_t
+{
+    NVTX_RESOURCE_TYPE_UNKNOWN = 0,
+    NVTX_RESOURCE_TYPE_GENERIC_POINTER = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 1), /**< Generic pointer assumed to have no collisions with other pointers. */
+    NVTX_RESOURCE_TYPE_GENERIC_HANDLE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 2), /**< Generic handle assumed to have no collisions with other handles. */
+    NVTX_RESOURCE_TYPE_GENERIC_THREAD_NATIVE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 3), /**< OS native thread identifier. */
+    NVTX_RESOURCE_TYPE_GENERIC_THREAD_POSIX = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 4) /**< POSIX pthread identifier. */
+} nvtxResourceGenericType_t;
+
+
+
+/** \brief Resource Attribute Structure.
+* \anchor RESOURCE_ATTRIBUTE_STRUCTURE
+*
+* This structure is used to describe the attributes of a resource. The layout of
+* the structure is defined by a specific version of the tools extension
+* library and can change between different versions of the Tools Extension
+* library.
+*
+* \par Initializing the Attributes
+*
+* The caller should always perform the following three tasks when using
+* attributes:
+* <ul>
+*    <li>Zero the structure
+*    <li>Set the version field
+*    <li>Set the size field
+* </ul>
+*
+* Zeroing the structure sets all the resource attributes types and values
+* to the default value.
+*
+* The version and size field are used by the Tools Extension
+* implementation to handle multiple versions of the attributes structure.
+*
+* It is recommended that the caller use one of the following to methods
+* to initialize the event attributes structure:
+*
+* \par Method 1: Initializing nvtxEventAttributes for future compatibility
+* \code
+* nvtxResourceAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
+* \endcode
+*
+* \par Method 2: Initializing nvtxEventAttributes for a specific version
+* \code
+* nvtxResourceAttributes_v0 attribs = {0};
+* attribs.version = 2;
+* attribs.size = (uint16_t)(sizeof(nvtxResourceAttributes_v0));
+* \endcode
+*
+* If the caller uses Method 1 it is critical that the entire binary
+* layout of the structure be configured to 0 so that all fields
+* are initialized to the default value.
+*
+* The caller should either use both NVTX_VERSION and
+* NVTX_RESOURCE_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values
+* and a versioned type (Method 2).  Using a mix of the two methods
+* will likely cause either source level incompatibility or binary
+* incompatibility in the future.
+*
+* \par Settings Attribute Types and Values
+*
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
+*
+* // Initialize
+* nvtxResourceAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
+*
+* // Configure the Attributes
+* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
+* attribs.identifier.pValue = (const void*)pMutex;
+* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* attribs.message.ascii = "Single thread access to database.";
+*
+* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, attribs);
+* \endcode
+*
+* \sa
+* ::nvtxDomainResourceCreate
+*/
+typedef struct nvtxResourceAttributes_v0
+{
+    /**
+    * \brief Version flag of the structure.
+    *
+    * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs
+    * supported in this header file. This can optionally be overridden to
+    * another version of the tools extension library.
+    */
+    uint16_t version;
+
+    /**
+    * \brief Size of the structure.
+    *
+    * Needs to be set to the size in bytes of this attribute
+    * structure.
+    */
+    uint16_t size;
+
+    /**
+    * \brief Identifier type specifies how to interpret the identifier field
+    *
+    * Defines the identifier format of the attribute structure's \ref RESOURCE_IDENTIFIER_FIELD
+    * "identifier" field.
+    *
+    * Default Value is NVTX_RESOURCE_TYPE_UNKNOWN
+    */
+    int32_t identifierType;            /* values from enums following the pattern nvtxResource[name]Type_t */
+
+    /**
+    * \brief Identifier for the resource. 
+    * \anchor RESOURCE_IDENTIFIER_FIELD
+    *
+    * An identifier may be a pointer or a handle to an OS or middleware API object.
+    * The resource type will assist in avoiding collisions where handles values may collide.
+    */
+    union identifier_t
+    {
+        const void* pValue;
+        uint64_t ullValue;
+    } identifier;
+
+    /** \brief Message type specified in this attribute structure.
+    *
+    * Defines the message format of the attribute structure's \ref RESOURCE_MESSAGE_FIELD
+    * "message" field.
+    *
+    * Default Value is NVTX_MESSAGE_UNKNOWN
+    */
+    int32_t messageType;            /* nvtxMessageType_t */
+
+    /** \brief Message assigned to this attribute structure. \anchor RESOURCE_MESSAGE_FIELD
+    *
+    * The text message that is attached to a resource.
+    */
+    nvtxMessageValue_t message;
+
+} nvtxResourceAttributes_v0;
+
+typedef struct nvtxResourceAttributes_v0 nvtxResourceAttributes_t;
+
+/* \cond SHOW_HIDDEN 
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_RESOURCE_ATTRIB_STRUCT_SIZE ( (uint16_t)( sizeof(nvtxResourceAttributes_v0) ) )
+typedef struct nvtxResourceHandle* nvtxResourceHandle_t;
+/** \endcond */
+
+
+
+/* ------------------------------------------------------------------------- */
+/** \brief Create a resource object to track and associate data with OS and middleware objects
+*
+* Allows users to associate an API handle or pointer with a user-provided name.
+* 
+*
+* \param domain - Domain to own the resource object
+* \param attribs - Attributes to be associated with the resource
+*
+* \return A handle that represents the newly created resource object.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
+* nvtxResourceAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
+* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
+* attribs.identifier.pValue = (const void*)pMutex;
+* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* attribs.message.ascii = "Single thread access to database.";
+* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, attribs);
+* \endcode
+*
+* \sa
+* ::nvtxResourceAttributes_t
+* ::nvtxDomainResourceDestroy
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC nvtxResourceHandle_t NVTX_API nvtxDomainResourceCreate(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Destroy a resource object to track and associate data with OS and middleware objects
+*
+* Allows users to associate an API handle or pointer with a user-provided name.
+*
+* \param resource - Handle to the resource in which to operate.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain");
+* nvtxResourceAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE;
+* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER;
+* attribs.identifier.pValue = (const void*)pMutex;
+* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* attribs.message.ascii = "Single thread access to database.";
+* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, attribs);
+* nvtxDomainResourceDestroy(handle);
+* \endcode
+*
+* \sa
+* ::nvtxDomainResourceCreate
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxDomainResourceDestroy(nvtxResourceHandle_t resource);
+/** @} */
+
+
+/** \name Functions for NVTX Category Naming*/
+
+/* ------------------------------------------------------------------------- */
+/**
+* \brief Annotate an NVTX category used within a domain.
+*
+* Categories are used to group sets of events. Each category is identified
+* through a unique ID and that ID is passed into any of the marker/range
+* events to assign that event to a specific category. The nvtxDomainNameCategory
+* function calls allow the user to assign a name to a category ID that is
+* specific to the domain.
+*
+* nvtxDomainNameCategory(NULL, category, name) is equivalent to calling
+* nvtxNameCategory(category, name).
+*
+* \param domain    - The domain of scoping the category.
+* \param category  - The category ID to name.
+* \param name      - The name of the category.
+*
+* \remarks The category names are tracked per domain.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("example");
+* nvtxDomainNameCategoryA(domain, 1, "Memory Allocation");
+* nvtxDomainNameCategoryW(domain, 2, L"Memory Transfer");
+* \endcode
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryA(nvtxDomainHandle_t domain, uint32_t category, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryW(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name);
+/** @} */
+
+/** \brief Annotate an NVTX category.
+ *
+ * Categories are used to group sets of events. Each category is identified
+ * through a unique ID and that ID is passed into any of the marker/range
+ * events to assign that event to a specific category. The nvtxNameCategory
+ * function calls allow the user to assign a name to a category ID.
+ *
+ * \param category - The category ID to name.
+ * \param name     - The name of the category.
+ *
+ * \remarks The category names are tracked per process.
+ *
+ * \par Example:
+ * \code
+ * nvtxNameCategory(1, "Memory Allocation");
+ * nvtxNameCategory(2, "Memory Transfer");
+ * nvtxNameCategory(3, "Memory Object Lifetime");
+ * \endcode
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCategoryA(uint32_t category, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCategoryW(uint32_t category, const wchar_t* name);
+/** @} */
+
+/** \name Functions for OS Threads Naming*/
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotate an OS thread.
+ *
+ * Allows the user to name an active thread of the current process. If an
+ * invalid thread ID is provided or a thread ID from a different process is
+ * used the behavior of the tool is implementation dependent.
+ *
+ * Tools expect thread ID to be a number that uniquely identifies the thread
+ * at the time of the call. Note that a thread's ID can be reused after
+ * it is destroyed. Tools may choose how to handle aliasing of thread IDs.
+ *
+ * POSIX pthread_t type returned by pthread_self() may not comply with these
+ * expectations. Please use OS-specific thread ID instead of pthread_t.
+ *
+ * The thread name is associated to the default domain.  To support domains 
+ * use resource objects via ::nvtxDomainResourceCreate.
+ *
+ * \param threadId - The ID of the thread to name.
+ * \param name     - The name of the thread.
+ *
+ * \par Examples:
+ * MS Windows:
+ * \code
+ * #include <windows.h>
+ * nvtxNameOsThread(GetCurrentThreadId(), "Current thread");
+ * nvtxNameOsThread(GetThreadId(SomeThreadHandle), "Other thread");
+ * \endcode
+ *
+ * Android:
+ * \code
+ * #include <unistd.h>
+ * nvtxNameOsThreadA(gettid(), "Current thread");
+ * nvtxNameOsThreadA(getpid(), "Main thread");
+ * \endcode
+ *
+ * Linux:
+ * \code
+ * #include <sys/syscall.h>
+ * nvtxNameOsThreadA(syscall(SYS_gettid), "Current thread");
+ * \endcode
+ * \code
+ * #include <unistd.h>
+ * nvtxNameOsThreadA(getpid(), "Main thread");
+ * \endcode
+ *
+ * OS X:
+ * \code
+ * #include <sys/syscall.h>
+ * nvtxNameOsThreadA(syscall(SYS_thread_selfid), "Current thread");
+ * \endcode
+ * \code
+ * #include <pthread.h>
+ * __uint64_t id;
+ * pthread_threadid_np(pthread_self(), &id);
+ * nvtxNameOsThreadA(id, "Current thread");
+ * pthread_threadid_np(somePThreadId, &id);
+ * nvtxNameOsThreadA(id, "Other thread");
+ * \endcode
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadA(uint32_t threadId, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadW(uint32_t threadId, const wchar_t* name);
+/** @} */
+
+
+/** @} */ /*END defgroup*/
+/* ========================================================================= */
+/** \defgroup STRING_REGISTRATION String Registration
+*
+* Registered strings are intended to increase performance by lowering instrumentation
+* overhead.  String may be registered once and the handle may be passed in place of
+* a string where an the APIs may allow.
+*
+* See \ref STRING_REGISTRATION for more details
+*
+* @{
+*/
+
+/* ------------------------------------------------------------------------- */
+/** \brief Register a string.
+
+* Registers an immutable string with NVTX. Once registered the pointer used
+* to register the domain name can be used in nvtxEventAttributes_t
+* \ref MESSAGE_FIELD. This allows NVTX implementation to skip copying the
+* contents of the message on each event invocation.
+*
+* String registration is an optimization. It is recommended to use string
+* registration if the string will be passed to an event many times.
+*
+* String are not unregistered, except that by unregistering the entire domain
+*
+* \param domain  - Domain handle. If NULL then the global domain is used.
+* \param string    - A unique pointer to a sequence of characters.
+*
+* \return A handle representing the registered string.
+*
+* \par Example:
+* \code
+* nvtxDomainCreateA("com.nvidia.nvtx.example");
+* nvtxStringHandle_t message = nvtxDomainRegisterStringA(domain, "registered string");
+* nvtxEventAttributes_t eventAttrib = {0};
+* eventAttrib.version = NVTX_VERSION;
+* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib.messageType = NVTX_MESSAGE_TYPE_REGISTERED;
+* eventAttrib.message.registered = message;
+* \endcode
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringA(nvtxDomainHandle_t domain, const char* string);
+NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringW(nvtxDomainHandle_t domain, const wchar_t* string);
+/** @} */
+
+/** @} */ /*END defgroup*/
+/* ========================================================================= */
+/** \defgroup DOMAINS Domains
+*
+* Domains are used to group events to a developer defined scope. Middleware
+* vendors may also scope their own events to avoid collisions with the
+* the application developer's events, so that the application developer may
+* inspect both parts and easily differentiate or filter them.  By default
+* all events are scoped to a global domain where NULL is provided or when
+* using APIs provided b versions of NVTX below v2
+*
+* Domains are intended to be typically long lived objects with the intention
+* of logically separating events of large modules from each other such as
+* middleware libraries from each other and the main application.
+*
+* See \ref DOMAINS for more details
+*
+* @{
+*/
+
+/* ------------------------------------------------------------------------- */
+/** \brief Register a NVTX domain.
+*
+* Domains are used to scope annotations. All NVTX_VERSION_0 and NVTX_VERSION_1
+* annotations are scoped to the global domain. The function nvtxDomainCreate
+* creates a new named domain.
+*
+* Each domain maintains its own nvtxRangePush and nvtxRangePop stack.
+*
+* \param name - A unique string representing the domain.
+*
+* \return A handle representing the domain.
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example");
+*
+* nvtxMarkA("nvtxMarkA to global domain");
+*
+* nvtxEventAttributes_t eventAttrib1 = {0};
+* eventAttrib1.version = NVTX_VERSION;
+* eventAttrib1.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib1.message.ascii = "nvtxDomainMarkEx to global domain";
+* nvtxDomainMarkEx(NULL, &eventAttrib1);
+*
+* nvtxEventAttributes_t eventAttrib2 = {0};
+* eventAttrib2.version = NVTX_VERSION;
+* eventAttrib2.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
+* eventAttrib2.message.ascii = "nvtxDomainMarkEx to com.nvidia.nvtx.example";
+* nvtxDomainMarkEx(domain, &eventAttrib2);
+* nvtxDomainDestroy(domain);
+* \endcode
+*
+* \sa
+* ::nvtxDomainDestroy
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateA(const char* name);
+NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateW(const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Unregister a NVTX domain.
+*
+* Unregisters the domain handle and frees all domain specific resources.
+*
+* \param domain    - the domain handle
+*
+* \par Example:
+* \code
+* nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example");
+* nvtxDomainDestroy(domain);
+* \endcode
+*
+* \sa
+* ::nvtxDomainCreateA
+* ::nvtxDomainCreateW
+*
+* \version \NVTX_VERSION_2
+* @{ */
+NVTX_DECLSPEC void NVTX_API nvtxDomainDestroy(nvtxDomainHandle_t domain);
+/** @} */
+
+
+/** @} */ /*END defgroup*/
+/* ========================================================================= */
+/** \cond SHOW_HIDDEN */
+
+#ifdef UNICODE
+    #define nvtxMark            nvtxMarkW
+    #define nvtxRangeStart      nvtxRangeStartW
+    #define nvtxRangePush       nvtxRangePushW
+    #define nvtxNameCategory    nvtxNameCategoryW
+    #define nvtxNameOsThread    nvtxNameOsThreadW
+    /* NVTX_VERSION_2 */
+    #define nvtxDomainCreate         nvtxDomainCreateW
+    #define nvtxDomainRegisterString nvtxDomainRegisterStringW
+    #define nvtxDomainNameCategory   nvtxDomainNameCategoryW
+#else
+    #define nvtxMark            nvtxMarkA
+    #define nvtxRangeStart      nvtxRangeStartA
+    #define nvtxRangePush       nvtxRangePushA
+    #define nvtxNameCategory    nvtxNameCategoryA
+    #define nvtxNameOsThread    nvtxNameOsThreadA
+    /* NVTX_VERSION_2 */
+    #define nvtxDomainCreate         nvtxDomainCreateA
+    #define nvtxDomainRegisterString nvtxDomainRegisterStringA
+    #define nvtxDomainNameCategory   nvtxDomainNameCategoryA
+#endif
+
+/** \endcond */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#define NVTX_IMPL_GUARD /* Ensure other headers cannot included directly */
+
+#include "nvtxDetail/nvtxTypes.h"
+
+#ifndef NVTX_NO_IMPL
+#include "nvtxDetail/nvtxImpl.h"
+#endif /*NVTX_NO_IMPL*/
+
+#undef NVTX_IMPL_GUARD
+
+#endif /* !defined(NVTX_VERSION) */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCuda.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCuda.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b1e71b7779089430b39e0fe3483ad536bb4bb7d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCuda.h
@@ -0,0 +1,170 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#include "nvToolsExt.h"
+
+#include "cuda.h"
+
+#ifndef NVTOOLSEXT_CUDA_V3
+#define NVTOOLSEXT_CUDA_V3
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* ========================================================================= */
+/** \name Functions for CUDA Resource Naming
+*/
+/** \addtogroup RESOURCE_NAMING
+ * \section RESOURCE_NAMING_CUDA CUDA Resource Naming
+ *
+ * This section covers the API functions that allow to annotate CUDA resources
+ * with user-provided names.
+ *
+ * @{
+ */
+
+/*  ------------------------------------------------------------------------- */
+/* \cond SHOW_HIDDEN 
+* \brief Used to build a non-colliding value for resource types separated class
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_RESOURCE_CLASS_CUDA  4
+/** \endcond */
+
+/*  ------------------------------------------------------------------------- */
+/** \brief Resource types for CUDA
+*/
+typedef enum nvtxResourceCUDAType_t
+{
+    NVTX_RESOURCE_TYPE_CUDA_DEVICE = NVTX_RESOURCE_MAKE_TYPE(CUDA, 1), /* CUdevice */
+    NVTX_RESOURCE_TYPE_CUDA_CONTEXT = NVTX_RESOURCE_MAKE_TYPE(CUDA, 2), /* CUcontext */
+    NVTX_RESOURCE_TYPE_CUDA_STREAM = NVTX_RESOURCE_MAKE_TYPE(CUDA, 3), /* CUstream */
+    NVTX_RESOURCE_TYPE_CUDA_EVENT = NVTX_RESOURCE_MAKE_TYPE(CUDA, 4), /* CUevent */
+} nvtxResourceCUDAType_t;
+
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA device.
+ *
+ * Allows the user to associate a CUDA device with a user-provided name.
+ *
+ * \param device - The handle of the CUDA device to name.
+ * \param name   - The name of the CUDA device.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCuDeviceA(CUdevice device, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCuDeviceW(CUdevice device, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA context.
+ *
+ * Allows the user to associate a CUDA context with a user-provided name.
+ *
+ * \param context - The handle of the CUDA context to name.
+ * \param name    - The name of the CUDA context.
+ *
+ * \par Example:
+ * \code
+ * CUresult status = cuCtxCreate( &cuContext, 0, cuDevice );
+ * if ( CUDA_SUCCESS != status )
+ *     goto Error;
+ * nvtxNameCuContext(cuContext, "CTX_NAME");
+ * \endcode
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCuContextA(CUcontext context, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCuContextW(CUcontext context, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA stream.
+ *
+ * Allows the user to associate a CUDA stream with a user-provided name.
+ *
+ * \param stream - The handle of the CUDA stream to name.
+ * \param name   - The name of the CUDA stream.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCuStreamA(CUstream stream, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCuStreamW(CUstream stream, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA event.
+ *
+ * Allows the user to associate a CUDA event with a user-provided name.
+ *
+ * \param event - The handle of the CUDA event to name.
+ * \param name  - The name of the CUDA event.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCuEventA(CUevent event, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCuEventW(CUevent event, const wchar_t* name);
+/** @} */
+
+/** @} */ /* END RESOURCE_NAMING */
+
+/* ========================================================================= */
+#ifdef UNICODE
+  #define nvtxNameCuDevice   nvtxNameCuDeviceW
+  #define nvtxNameCuContext  nvtxNameCuContextW
+  #define nvtxNameCuStream   nvtxNameCuStreamW
+  #define nvtxNameCuEvent    nvtxNameCuEventW
+#else
+  #define nvtxNameCuDevice   nvtxNameCuDeviceA
+  #define nvtxNameCuContext  nvtxNameCuContextA
+  #define nvtxNameCuStream   nvtxNameCuStreamA
+  #define nvtxNameCuEvent    nvtxNameCuEventA
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifndef NVTX_NO_IMPL
+#define NVTX_IMPL_GUARD_CUDA /* Ensure other headers cannot included directly */
+#include "nvtxDetail/nvtxImplCuda_v3.h"
+#undef NVTX_IMPL_GUARD_CUDA
+#endif /*NVTX_NO_IMPL*/
+
+#endif /* NVTOOLSEXT_CUDA_V3 */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCudaRt.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCudaRt.h
new file mode 100644
index 0000000000000000000000000000000000000000..044d3dab5c32e7ec6646f3a1f3e9d89e52d40ba2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtCudaRt.h
@@ -0,0 +1,146 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#include "nvToolsExt.h"
+
+#include "cuda.h"
+#include "driver_types.h"
+
+#ifndef NVTOOLSEXT_CUDART_V3
+#define NVTOOLSEXT_CUDART_V3
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* ========================================================================= */
+/** \name Functions for CUDA Resource Naming
+*/
+/** \addtogroup RESOURCE_NAMING
+ * \section RESOURCE_NAMING_CUDART CUDA Runtime Resource Naming
+ *
+ * This section covers the API functions that allow to annotate CUDA resources
+ * with user-provided names.
+ *
+ * @{
+ */
+
+/*  ------------------------------------------------------------------------- */
+/* \cond SHOW_HIDDEN 
+* \brief Used to build a non-colliding value for resource types separated class
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_RESOURCE_CLASS_CUDART 5
+/** \endcond */
+
+/*  ------------------------------------------------------------------------- */
+/** \brief Resource types for CUDART
+*/
+typedef enum nvtxResourceCUDARTType_t
+{
+    NVTX_RESOURCE_TYPE_CUDART_DEVICE = NVTX_RESOURCE_MAKE_TYPE(CUDART, 0), /* int device */
+    NVTX_RESOURCE_TYPE_CUDART_STREAM = NVTX_RESOURCE_MAKE_TYPE(CUDART, 1), /* cudaStream_t */
+    NVTX_RESOURCE_TYPE_CUDART_EVENT = NVTX_RESOURCE_MAKE_TYPE(CUDART, 2), /* cudaEvent_t */
+} nvtxResourceCUDARTType_t;
+
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA device.
+ *
+ * Allows the user to associate a CUDA device with a user-provided name.
+ *
+ * \param device - The id of the CUDA device to name.
+ * \param name   - The name of the CUDA device.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaDeviceA(int device, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaDeviceW(int device, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA stream.
+ *
+ * Allows the user to associate a CUDA stream with a user-provided name.
+ *
+ * \param stream - The handle of the CUDA stream to name.
+ * \param name   - The name of the CUDA stream.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaStreamA(cudaStream_t stream, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaStreamW(cudaStream_t stream, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates a CUDA event.
+ *
+ * Allows the user to associate a CUDA event with a user-provided name.
+ *
+ * \param event - The handle of the CUDA event to name.
+ * \param name  - The name of the CUDA event.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaEventA(cudaEvent_t event, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaEventW(cudaEvent_t event, const wchar_t* name);
+/** @} */
+
+/** @} */ /* END RESOURCE_NAMING */
+
+/* ========================================================================= */
+#ifdef UNICODE
+  #define nvtxNameCudaDevice nvtxNameCudaDeviceW
+  #define nvtxNameCudaStream nvtxNameCudaStreamW
+  #define nvtxNameCudaEvent  nvtxNameCudaEventW
+#else
+  #define nvtxNameCudaDevice nvtxNameCudaDeviceA
+  #define nvtxNameCudaStream nvtxNameCudaStreamA
+  #define nvtxNameCudaEvent  nvtxNameCudaEventA
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifndef NVTX_NO_IMPL
+#define NVTX_IMPL_GUARD_CUDART /* Ensure other headers cannot included directly */
+#include "nvtxDetail/nvtxImplCudaRt_v3.h"
+#undef NVTX_IMPL_GUARD_CUDART
+#endif /*NVTX_NO_IMPL*/
+
+#endif /* NVTOOLSEXT_CUDART_V3 */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtOpenCL.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtOpenCL.h
new file mode 100644
index 0000000000000000000000000000000000000000..38a9290b438d30f8450b6ea2f4e5de68d37d4a97
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtOpenCL.h
@@ -0,0 +1,220 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#include "nvToolsExt.h"
+
+#include <CL/cl.h>
+
+#ifndef NVTOOLSEXT_OPENCL_V3
+#define NVTOOLSEXT_OPENCL_V3
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* ========================================================================= */
+/** \name Functions for OpenCL Resource Naming
+ */
+/** \addtogroup RESOURCE_NAMING
+ * \section RESOURCE_NAMING_OPENCL OpenCL Resource Naming
+ *
+ * This section covers the API functions that allow to annotate OpenCL resources
+ * with user-provided names.
+ *
+ * @{
+ */
+
+/*  ------------------------------------------------------------------------- */
+/* \cond SHOW_HIDDEN 
+* \brief Used to build a non-colliding value for resource types separated class
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_RESOURCE_CLASS_OPENCL 6 
+/** \endcond */
+
+/*  ------------------------------------------------------------------------- */
+/** \brief Resource types for OpenCL
+*/
+typedef enum nvtxResourceOpenCLType_t
+{
+    NVTX_RESOURCE_TYPE_OPENCL_DEVICE = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 1),
+    NVTX_RESOURCE_TYPE_OPENCL_CONTEXT = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 2),
+    NVTX_RESOURCE_TYPE_OPENCL_COMMANDQUEUE = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 3),
+    NVTX_RESOURCE_TYPE_OPENCL_MEMOBJECT = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 4),
+    NVTX_RESOURCE_TYPE_OPENCL_SAMPLER = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 5),
+    NVTX_RESOURCE_TYPE_OPENCL_PROGRAM = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 6),
+    NVTX_RESOURCE_TYPE_OPENCL_EVENT = NVTX_RESOURCE_MAKE_TYPE(OPENCL, 7),
+} nvtxResourceOpenCLType_t;
+
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL device.
+ *
+ * Allows to associate an OpenCL device with a user-provided name.
+ *
+ * \param device - The handle of the OpenCL device to name.
+ * \param name   - The name of the OpenCL device.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClDeviceA(cl_device_id device, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClDeviceW(cl_device_id device, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL context.
+ *
+ * Allows to associate an OpenCL context with a user-provided name.
+ *
+ * \param context - The handle of the OpenCL context to name.
+ * \param name    - The name of the OpenCL context.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClContextA(cl_context context, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClContextW(cl_context context, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL command queue.
+ *
+ * Allows to associate an OpenCL command queue with a user-provided name.
+ *
+ * \param command_queue - The handle of the OpenCL command queue to name.
+ * \param name          - The name of the OpenCL command queue.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClCommandQueueA(cl_command_queue command_queue, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClCommandQueueW(cl_command_queue command_queue, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL memory object.
+ *
+ * Allows to associate an OpenCL memory object with a user-provided name.
+ *
+ * \param memobj - The handle of the OpenCL memory object to name.
+ * \param name   - The name of the OpenCL memory object.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClMemObjectA(cl_mem memobj, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClMemObjectW(cl_mem memobj, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL sampler.
+ *
+ * Allows to associate an OpenCL sampler with a user-provided name.
+ *
+ * \param sampler - The handle of the OpenCL sampler to name.
+ * \param name    - The name of the OpenCL sampler.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClSamplerA(cl_sampler sampler, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClSamplerW(cl_sampler sampler, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL program.
+ *
+ * Allows to associate an OpenCL program with a user-provided name.
+ *
+ * \param program - The handle of the OpenCL program to name.
+ * \param name    - The name of the OpenCL program.
+ *
+ * \code
+ * cpProgram = clCreateProgramWithSource(cxGPUContext, 1,
+ *     (const char **) &cSourceCL, &program_length, &ciErrNum);
+ * shrCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+ * nvtxNameClProgram(cpProgram, L"PROGRAM_NAME");
+ * \endcode
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClProgramA(cl_program program, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClProgramW(cl_program program, const wchar_t* name);
+/** @} */
+
+/* ------------------------------------------------------------------------- */
+/** \brief Annotates an OpenCL event.
+ *
+ * Allows to associate an OpenCL event with a user-provided name.
+ *
+ * \param evnt - The handle of the OpenCL event to name.
+ * \param name - The name of the OpenCL event.
+ *
+ * \version \NVTX_VERSION_1
+ * @{ */
+NVTX_DECLSPEC void NVTX_API nvtxNameClEventA(cl_event evnt, const char* name);
+NVTX_DECLSPEC void NVTX_API nvtxNameClEventW(cl_event evnt, const wchar_t* name);
+/** @} */
+
+/** @} */ /* END RESOURCE_NAMING */
+
+/* ========================================================================= */
+#ifdef UNICODE
+  #define nvtxNameClDevice        nvtxNameClDeviceW
+  #define nvtxNameClContext       nvtxNameClContextW
+  #define nvtxNameClCommandQueue  nvtxNameClCommandQueueW
+  #define nvtxNameClMemObject     nvtxNameClMemObjectW
+  #define nvtxNameClSampler       nvtxNameClSamplerW
+  #define nvtxNameClProgram       nvtxNameClProgramW
+  #define nvtxNameClEvent         nvtxNameClEventW
+#else
+  #define nvtxNameClDevice        nvtxNameClDeviceA
+  #define nvtxNameClContext       nvtxNameClContextA
+  #define nvtxNameClCommandQueue  nvtxNameClCommandQueueA
+  #define nvtxNameClMemObject     nvtxNameClMemObjectA
+  #define nvtxNameClSampler       nvtxNameClSamplerA
+  #define nvtxNameClProgram       nvtxNameClProgramA
+  #define nvtxNameClEvent         nvtxNameClEventA
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifndef NVTX_NO_IMPL
+#define NVTX_IMPL_GUARD_OPENCL /* Ensure other headers cannot included directly */
+#include "nvtxDetail/nvtxImplOpenCL_v3.h"
+#undef NVTX_IMPL_GUARD_OPENCL
+#endif /*NVTX_NO_IMPL*/
+
+#endif /* NVTOOLSEXT_OPENCL_V3 */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtSync.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtSync.h
new file mode 100644
index 0000000000000000000000000000000000000000..afc3db98fe1b05d8dfb309221243ae3b4c14dd9d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvToolsExtSync.h
@@ -0,0 +1,411 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#include "nvToolsExt.h"
+
+#ifndef NVTOOLSEXT_SYNC_V3
+#define NVTOOLSEXT_SYNC_V3
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* \cond SHOW_HIDDEN 
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_SYNCUSER_ATTRIB_STRUCT_SIZE ( (uint16_t)( sizeof(nvtxSyncUserAttributes_v0) ) )
+/** \endcond */
+
+
+/** 
+* \page PAGE_SYNCHRONIZATION Synchronization
+*
+* This section covers a subset of the API that allow users to track additional
+* synchronization details of their application.   Naming OS synchronization primitives 
+* may allow users to better understand the data collected by traced synchronization 
+* APIs.  Additionally, a user defined synchronization object can allow the users to
+* to tell the tools when the user is building their own synchronization system
+* that do not rely on the OS to provide behaviors and instead use techniques like
+* atomic operations and spinlocks.  
+*
+* See module \ref SYNCHRONIZATION for details.
+*
+* \par Example:
+* \code
+* class MyMutex
+* {
+*     volatile long bLocked;
+*     nvtxSyncUser_t hSync;
+* public:
+*     MyMutex(const char* name, nvtxDomainHandle_t d){
+*          bLocked = 0;
+*
+*          nvtxSyncUserAttributes_t attribs = { 0 };
+*          attribs.version = NVTX_VERSION;
+*          attribs.size = NVTX_SYNCUSER_ATTRIB_STRUCT_SIZE;
+*          attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
+*          attribs.message.ascii = name;
+*          hSync = nvtxDomainSyncUserCreate(d, &attribs);
+*     }
+*
+*     ~MyMutex() {
+*          nvtxDomainSyncUserDestroy(hSync);
+*     }
+*
+*     bool Lock() {
+*          nvtxDomainSyncUserAcquireStart(hSync);
+*          bool acquired = __sync_bool_compare_and_swap(&bLocked, 0, 1);//atomic compiler intrinsic 
+
+*          if (acquired) {
+*              nvtxDomainSyncUserAcquireSuccess(hSync);
+*          }
+*          else {
+*              nvtxDomainSyncUserAcquireFailed(hSync);
+*          }
+*          return acquired;
+*     }
+
+*     void Unlock() {
+*          nvtxDomainSyncUserReleasing(hSync);
+*          bLocked = false;
+*     }
+* };
+* \endcode
+* 
+* \version \NVTX_VERSION_2
+*/
+
+/*  ------------------------------------------------------------------------- */
+/* \cond SHOW_HIDDEN 
+* \brief Used to build a non-colliding value for resource types separated class
+* \version \NVTX_VERSION_2
+*/
+#define NVTX_RESOURCE_CLASS_SYNC_OS 2 /**< Synchronization objects that are OS specific. */
+#define NVTX_RESOURCE_CLASS_SYNC_PTHREAD 3 /**< Synchronization objects that are from the POSIX Threads API (pthread)*/
+/** \endcond */
+
+
+/*  ------------------------------------------------------------------------- */
+/** \defgroup SYNCHRONIZATION Synchronization
+* See page \ref PAGE_SYNCHRONIZATION.
+* @{
+*/
+
+/** \brief Resource type values for OSs with POSIX Thread API support
+ */
+typedef enum nvtxResourceSyncPosixThreadType_t
+{
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_MUTEX = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 1), /* pthread_mutex_t  */
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_CONDITION = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 2), /* pthread_cond_t  */
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_RWLOCK = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 3), /* pthread_rwlock_t  */
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_BARRIER = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 4), /* pthread_barrier_t  */
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_SPINLOCK = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 5), /* pthread_spinlock_t  */
+    NVTX_RESOURCE_TYPE_SYNC_PTHREAD_ONCE = NVTX_RESOURCE_MAKE_TYPE(SYNC_PTHREAD, 6) /* pthread_once_t  */
+} nvtxResourceSyncPosixThreadType_t;
+
+/** \brief Resource type values for Windows OSs
+*/
+typedef enum nvtxResourceSyncWindowsType_t
+{
+    NVTX_RESOURCE_TYPE_SYNC_WINDOWS_MUTEX = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 1),
+    NVTX_RESOURCE_TYPE_SYNC_WINDOWS_SEMAPHORE = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 2),
+    NVTX_RESOURCE_TYPE_SYNC_WINDOWS_EVENT = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 3),
+    NVTX_RESOURCE_TYPE_SYNC_WINDOWS_CRITICAL_SECTION = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 4),
+    NVTX_RESOURCE_TYPE_SYNC_WINDOWS_SRWLOCK = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 5)
+} nvtxResourceSyncWindowsType_t;
+
+/** \brief Resource type values for Linux and Linux derived OSs such as Android
+* \sa
+* ::nvtxResourceSyncPosixThreadType_t
+*/
+typedef enum nvtxResourceSyncLinuxType_t
+{
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_MUTEX = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 1),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_FUTEX = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 2),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_SEMAPHORE = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 3),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_COMPLETION = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 4),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_SPINLOCK = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 5),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_SEQLOCK = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 6),
+    NVTX_RESOURCE_TYPE_SYNC_LINUX_RCU = NVTX_RESOURCE_MAKE_TYPE(SYNC_OS, 7)
+} nvtxResourceSyncLinuxType_t;
+
+/** \brief Resource type values for Android come from Linux.
+* \sa
+* ::nvtxResourceSyncLinuxType_t
+* ::nvtxResourceSyncPosixThreadType_t
+*/
+typedef enum nvtxResourceSyncLinuxType_t nvtxResourceSyncAndroidType_t;
+
+/** \brief User Defined Synchronization Object Handle .
+* \anchor SYNCUSER_HANDLE_STRUCTURE
+*
+* This structure is opaque to the user and is used as a handle to reference
+* a user defined syncrhonization object.  The tools will return a pointer through the API for the application
+* to hold on it's behalf to reference the string in the future.
+*
+*/
+typedef struct nvtxSyncUser* nvtxSyncUser_t;
+
+/** \brief User Defined Synchronization Object Attributes Structure.
+* \anchor USERDEF_SYNC_ATTRIBUTES_STRUCTURE
+*
+* This structure is used to describe the attributes of a user defined synchronization 
+* object.  The layout of the structure is defined by a specific version of the tools 
+* extension library and can change between different versions of the Tools Extension
+* library.
+*
+* \par Initializing the Attributes
+*
+* The caller should always perform the following three tasks when using
+* attributes:
+* <ul>
+*    <li>Zero the structure
+*    <li>Set the version field
+*    <li>Set the size field
+* </ul>
+*
+* Zeroing the structure sets all the event attributes types and values
+* to the default value.
+*
+* The version and size field are used by the Tools Extension
+* implementation to handle multiple versions of the attributes structure.
+*
+* It is recommended that the caller use one of the following to methods
+* to initialize the event attributes structure:
+*
+* \par Method 1: Initializing nvtxEventAttributes for future compatibility
+* \code
+* nvtxSyncUserAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_SYNCUSER_ATTRIB_STRUCT_SIZE;
+* \endcode
+*
+* \par Method 2: Initializing nvtxSyncUserAttributes_t for a specific version
+* \code
+* nvtxSyncUserAttributes_t attribs = {0};
+* attribs.version = 1;
+* attribs.size = (uint16_t)(sizeof(nvtxSyncUserAttributes_t));
+* \endcode
+*
+* If the caller uses Method 1 it is critical that the entire binary
+* layout of the structure be configured to 0 so that all fields
+* are initialized to the default value.
+*
+* The caller should either use both NVTX_VERSION and
+* NVTX_SYNCUSER_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values
+* and a versioned type (Method 2).  Using a mix of the two methods
+* will likely cause either source level incompatibility or binary
+* incompatibility in the future.
+*
+* \par Settings Attribute Types and Values
+*
+*
+* \par Example:
+* \code
+* // Initialize
+* nvtxSyncUserAttributes_t attribs = {0};
+* attribs.version = NVTX_VERSION;
+* attribs.size = NVTX_SYNCUSER_ATTRIB_STRUCT_SIZE;
+*
+* // Configure the Attributes
+* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII;
+* attribs.message.ascii = "Example";
+* \endcode
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+*/
+typedef struct nvtxSyncUserAttributes_v0
+{
+    /**
+    * \brief Version flag of the structure.
+    *
+    * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs
+    * supported in this header file. This can optionally be overridden to
+    * another version of the tools extension library.
+    */
+    uint16_t version;
+
+    /**
+    * \brief Size of the structure.
+    *
+    * Needs to be set to the size in bytes of the event attribute
+    * structure used to specify the event.
+    */
+    uint16_t size;
+
+    /** \brief Message type specified in this attribute structure.
+    *
+    * Defines the message format of the attribute structure's \ref nvtxSyncUserAttributes_v0::message
+    * "message" field.
+    *
+    * Default Value is NVTX_MESSAGE_UNKNOWN
+    */
+    int32_t messageType;            /* nvtxMessageType_t */
+
+    /** \brief Message assigned to this attribute structure.
+    *
+    * The text message that is attached to an event.
+    */
+    nvtxMessageValue_t message;
+
+} nvtxSyncUserAttributes_v0;
+
+typedef struct nvtxSyncUserAttributes_v0 nvtxSyncUserAttributes_t;
+
+/* ------------------------------------------------------------------------- */
+/** \brief Create a user defined synchronization object 
+* This is used to track non-OS synchronization working with spinlocks and atomics
+*
+* \param domain - Domain to own the resource
+* \param attribs - A structure to assign multiple attributes to the object.
+*
+* \return A handle that represents the newly created user defined synchronization object.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/
+NVTX_DECLSPEC nvtxSyncUser_t NVTX_API nvtxDomainSyncUserCreate(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs);
+
+/* ------------------------------------------------------------------------- */
+/** \brief Destroy a user defined synchronization object
+* This is used to track non-OS synchronization working with spinlocks and atomics
+*
+* \param handle - A handle to the object to operate on.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserDestroy(nvtxSyncUser_t handle);
+
+/* ------------------------------------------------------------------------- */
+/** \brief Signal to tools that an attempt to acquire a user defined synchronization object
+*
+* \param handle - A handle to the object to operate on.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireStart(nvtxSyncUser_t handle);
+
+/* ------------------------------------------------------------------------- */
+/** \brief Signal to tools of failure in acquiring a user defined synchronization object
+* This should be called after \ref nvtxDomainSyncUserAcquireStart
+* 
+* \param handle - A handle to the object to operate on.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireFailed(nvtxSyncUser_t handle);
+
+/* ------------------------------------------------------------------------- */
+/** \brief Signal to tools of success in acquiring a user defined synchronization object
+* This should be called after \ref nvtxDomainSyncUserAcquireStart.
+*
+* \param handle - A handle to the object to operate on.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireSuccess(nvtxSyncUser_t handle);
+
+/* ------------------------------------------------------------------------- */
+/** \brief Signal to tools of releasing a reservation on user defined synchronization object
+* This should be called after \ref nvtxDomainSyncUserAcquireSuccess.
+*
+* \param handle - A handle to the object to operate on.
+*
+* \sa
+* ::nvtxDomainSyncUserCreate
+* ::nvtxDomainSyncUserDestroy
+* ::nvtxDomainSyncUserAcquireStart
+* ::nvtxDomainSyncUserAcquireFailed
+* ::nvtxDomainSyncUserAcquireSuccess
+* ::nvtxDomainSyncUserReleasing
+*
+* \version \NVTX_VERSION_2
+*/
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserReleasing(nvtxSyncUser_t handle);
+
+
+/** @} */ /*END defgroup*/
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifndef NVTX_NO_IMPL
+#define NVTX_IMPL_GUARD_SYNC /* Ensure other headers cannot included directly */
+#include "nvtxDetail/nvtxImplSync_v3.h"
+#undef NVTX_IMPL_GUARD_SYNC
+#endif /*NVTX_NO_IMPL*/
+
+#endif /* NVTOOLSEXT_SYNC_V3 */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImpl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdc6bd4c72d74ef0f1fe5c2c8b4c49b196927fa7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImpl.h
@@ -0,0 +1,469 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD
+#error Never include this file directly -- it is automatically included by nvToolsExt.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+/* ---- Include required platform headers ---- */
+
+#if defined(_WIN32) 
+
+#include <Windows.h>
+
+#else
+#include <unistd.h>
+
+#if defined(__ANDROID__)
+#include <android/api-level.h> 
+#endif
+
+#if defined(__linux__) || defined(__CYGWIN__)
+#include <sched.h>
+#endif
+
+#include <limits.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <string.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+#endif
+
+/* ---- Define macros used in this file ---- */
+
+#define NVTX_INIT_STATE_FRESH 0
+#define NVTX_INIT_STATE_STARTED 1
+#define NVTX_INIT_STATE_COMPLETE 2
+
+#ifdef NVTX_DEBUG_PRINT
+#ifdef __ANDROID__
+#include <android/log.h>
+#define NVTX_ERR(...) __android_log_print(ANDROID_LOG_ERROR, "NVTOOLSEXT", __VA_ARGS__);
+#define NVTX_INFO(...) __android_log_print(ANDROID_LOG_INFO, "NVTOOLSEXT", __VA_ARGS__);
+#else
+#include <stdio.h>
+#define NVTX_ERR(...) fprintf(stderr, "NVTX_ERROR: " __VA_ARGS__)
+#define NVTX_INFO(...) fprintf(stderr, "NVTX_INFO: " __VA_ARGS__)
+#endif
+#else /* !defined(NVTX_DEBUG_PRINT) */
+#define NVTX_ERR(...)
+#define NVTX_INFO(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifdef __GNUC__
+#pragma GCC visibility push(hidden)
+#endif
+
+/* ---- Forward declare all functions referenced in globals ---- */
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)(void);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxEtiGetModuleFunctionTable)(
+    NvtxCallbackModule module,
+    NvtxFunctionTable* out_table,
+    unsigned int* out_size);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxEtiSetInjectionNvtxVersion)(
+    uint32_t version);
+NVTX_LINKONCE_FWDDECL_FUNCTION const void* NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxGetExportTable)(
+    uint32_t exportTableId);
+
+#include "nvtxInitDecls.h"
+
+/* ---- Define all globals ---- */
+
+typedef struct nvtxGlobals_t
+{
+    volatile unsigned int initState;
+    NvtxExportTableCallbacks etblCallbacks;
+    NvtxExportTableVersionInfo etblVersionInfo;
+
+    /* Implementation function pointers */
+    nvtxMarkEx_impl_fntype nvtxMarkEx_impl_fnptr;
+    nvtxMarkA_impl_fntype nvtxMarkA_impl_fnptr;
+    nvtxMarkW_impl_fntype nvtxMarkW_impl_fnptr;
+    nvtxRangeStartEx_impl_fntype nvtxRangeStartEx_impl_fnptr;
+    nvtxRangeStartA_impl_fntype nvtxRangeStartA_impl_fnptr;
+    nvtxRangeStartW_impl_fntype nvtxRangeStartW_impl_fnptr;
+    nvtxRangeEnd_impl_fntype nvtxRangeEnd_impl_fnptr;
+    nvtxRangePushEx_impl_fntype nvtxRangePushEx_impl_fnptr;
+    nvtxRangePushA_impl_fntype nvtxRangePushA_impl_fnptr;
+    nvtxRangePushW_impl_fntype nvtxRangePushW_impl_fnptr;
+    nvtxRangePop_impl_fntype nvtxRangePop_impl_fnptr;
+    nvtxNameCategoryA_impl_fntype nvtxNameCategoryA_impl_fnptr;
+    nvtxNameCategoryW_impl_fntype nvtxNameCategoryW_impl_fnptr;
+    nvtxNameOsThreadA_impl_fntype nvtxNameOsThreadA_impl_fnptr;
+    nvtxNameOsThreadW_impl_fntype nvtxNameOsThreadW_impl_fnptr;
+
+    nvtxNameCuDeviceA_fakeimpl_fntype nvtxNameCuDeviceA_impl_fnptr;
+    nvtxNameCuDeviceW_fakeimpl_fntype nvtxNameCuDeviceW_impl_fnptr;
+    nvtxNameCuContextA_fakeimpl_fntype nvtxNameCuContextA_impl_fnptr;
+    nvtxNameCuContextW_fakeimpl_fntype nvtxNameCuContextW_impl_fnptr;
+    nvtxNameCuStreamA_fakeimpl_fntype nvtxNameCuStreamA_impl_fnptr;
+    nvtxNameCuStreamW_fakeimpl_fntype nvtxNameCuStreamW_impl_fnptr;
+    nvtxNameCuEventA_fakeimpl_fntype nvtxNameCuEventA_impl_fnptr;
+    nvtxNameCuEventW_fakeimpl_fntype nvtxNameCuEventW_impl_fnptr;
+
+    nvtxNameClDeviceA_fakeimpl_fntype nvtxNameClDeviceA_impl_fnptr;
+    nvtxNameClDeviceW_fakeimpl_fntype nvtxNameClDeviceW_impl_fnptr;
+    nvtxNameClContextA_fakeimpl_fntype nvtxNameClContextA_impl_fnptr;
+    nvtxNameClContextW_fakeimpl_fntype nvtxNameClContextW_impl_fnptr;
+    nvtxNameClCommandQueueA_fakeimpl_fntype nvtxNameClCommandQueueA_impl_fnptr;
+    nvtxNameClCommandQueueW_fakeimpl_fntype nvtxNameClCommandQueueW_impl_fnptr;
+    nvtxNameClMemObjectA_fakeimpl_fntype nvtxNameClMemObjectA_impl_fnptr;
+    nvtxNameClMemObjectW_fakeimpl_fntype nvtxNameClMemObjectW_impl_fnptr;
+    nvtxNameClSamplerA_fakeimpl_fntype nvtxNameClSamplerA_impl_fnptr;
+    nvtxNameClSamplerW_fakeimpl_fntype nvtxNameClSamplerW_impl_fnptr;
+    nvtxNameClProgramA_fakeimpl_fntype nvtxNameClProgramA_impl_fnptr;
+    nvtxNameClProgramW_fakeimpl_fntype nvtxNameClProgramW_impl_fnptr;
+    nvtxNameClEventA_fakeimpl_fntype nvtxNameClEventA_impl_fnptr;
+    nvtxNameClEventW_fakeimpl_fntype nvtxNameClEventW_impl_fnptr;
+
+    nvtxNameCudaDeviceA_impl_fntype nvtxNameCudaDeviceA_impl_fnptr;
+    nvtxNameCudaDeviceW_impl_fntype nvtxNameCudaDeviceW_impl_fnptr;
+    nvtxNameCudaStreamA_fakeimpl_fntype nvtxNameCudaStreamA_impl_fnptr;
+    nvtxNameCudaStreamW_fakeimpl_fntype nvtxNameCudaStreamW_impl_fnptr;
+    nvtxNameCudaEventA_fakeimpl_fntype nvtxNameCudaEventA_impl_fnptr;
+    nvtxNameCudaEventW_fakeimpl_fntype nvtxNameCudaEventW_impl_fnptr;
+
+    nvtxDomainMarkEx_impl_fntype nvtxDomainMarkEx_impl_fnptr;
+    nvtxDomainRangeStartEx_impl_fntype nvtxDomainRangeStartEx_impl_fnptr;
+    nvtxDomainRangeEnd_impl_fntype nvtxDomainRangeEnd_impl_fnptr;
+    nvtxDomainRangePushEx_impl_fntype nvtxDomainRangePushEx_impl_fnptr;
+    nvtxDomainRangePop_impl_fntype nvtxDomainRangePop_impl_fnptr;
+    nvtxDomainResourceCreate_impl_fntype nvtxDomainResourceCreate_impl_fnptr;
+    nvtxDomainResourceDestroy_impl_fntype nvtxDomainResourceDestroy_impl_fnptr;
+    nvtxDomainNameCategoryA_impl_fntype nvtxDomainNameCategoryA_impl_fnptr;
+    nvtxDomainNameCategoryW_impl_fntype nvtxDomainNameCategoryW_impl_fnptr;
+    nvtxDomainRegisterStringA_impl_fntype nvtxDomainRegisterStringA_impl_fnptr;
+    nvtxDomainRegisterStringW_impl_fntype nvtxDomainRegisterStringW_impl_fnptr;
+    nvtxDomainCreateA_impl_fntype nvtxDomainCreateA_impl_fnptr;
+    nvtxDomainCreateW_impl_fntype nvtxDomainCreateW_impl_fnptr;
+    nvtxDomainDestroy_impl_fntype nvtxDomainDestroy_impl_fnptr;
+    nvtxInitialize_impl_fntype nvtxInitialize_impl_fnptr;
+
+    nvtxDomainSyncUserCreate_impl_fntype nvtxDomainSyncUserCreate_impl_fnptr;
+    nvtxDomainSyncUserDestroy_impl_fntype nvtxDomainSyncUserDestroy_impl_fnptr;
+    nvtxDomainSyncUserAcquireStart_impl_fntype nvtxDomainSyncUserAcquireStart_impl_fnptr;
+    nvtxDomainSyncUserAcquireFailed_impl_fntype nvtxDomainSyncUserAcquireFailed_impl_fnptr;
+    nvtxDomainSyncUserAcquireSuccess_impl_fntype nvtxDomainSyncUserAcquireSuccess_impl_fnptr;
+    nvtxDomainSyncUserReleasing_impl_fntype nvtxDomainSyncUserReleasing_impl_fnptr;
+
+    /* Tables of function pointers -- Extra null added to the end to ensure
+    *  a crash instead of silent corruption if a tool reads off the end. */
+    NvtxFunctionPointer* functionTable_CORE  [NVTX_CBID_CORE_SIZE   + 1];
+    NvtxFunctionPointer* functionTable_CUDA  [NVTX_CBID_CUDA_SIZE   + 1];
+    NvtxFunctionPointer* functionTable_OPENCL[NVTX_CBID_OPENCL_SIZE + 1];
+    NvtxFunctionPointer* functionTable_CUDART[NVTX_CBID_CUDART_SIZE + 1];
+    NvtxFunctionPointer* functionTable_CORE2 [NVTX_CBID_CORE2_SIZE  + 1];
+    NvtxFunctionPointer* functionTable_SYNC  [NVTX_CBID_SYNC_SIZE   + 1];
+} nvtxGlobals_t;
+
+NVTX_LINKONCE_DEFINE_GLOBAL nvtxGlobals_t NVTX_VERSIONED_IDENTIFIER(nvtxGlobals) =
+{
+    NVTX_INIT_STATE_FRESH,
+
+    {
+        sizeof(NvtxExportTableCallbacks),
+        NVTX_VERSIONED_IDENTIFIER(nvtxEtiGetModuleFunctionTable)
+    },
+    {
+        sizeof(NvtxExportTableVersionInfo),
+        NVTX_VERSION,
+        0,
+        NVTX_VERSIONED_IDENTIFIER(nvtxEtiSetInjectionNvtxVersion)
+    },
+
+    /* Implementation function pointers */
+    NVTX_VERSIONED_IDENTIFIER(nvtxMarkEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxMarkA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxMarkW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangeEnd_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangePushEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangePushA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangePushW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxRangePop_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadW_impl_init),
+
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventW_impl_init),
+
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventW_impl_init),
+
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventW_impl_init),
+
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainMarkEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeStartEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeEnd_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePushEx_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePop_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceCreate_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceDestroy_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateA_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateW_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainDestroy_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitialize_impl_init),
+
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserCreate_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserDestroy_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireStart_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireFailed_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireSuccess_impl_init),
+    NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserReleasing_impl_init),
+
+    /* Tables of function pointers */
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeEnd_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePop_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadW_impl_fnptr,
+        0
+    },
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventW_impl_fnptr,
+        0
+    },
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventW_impl_fnptr,
+        0
+    },
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventW_impl_fnptr,
+        0
+    },
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainMarkEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeStartEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeEnd_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePushEx_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePop_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceCreate_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceDestroy_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateA_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateW_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainDestroy_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxInitialize_impl_fnptr,
+        0
+    },
+    {
+        0,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserCreate_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserDestroy_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireStart_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireFailed_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireSuccess_impl_fnptr,
+        (NvtxFunctionPointer*)&NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserReleasing_impl_fnptr,
+        0
+    }
+};
+
+/* ---- Define static inline implementations of core API functions ---- */
+
+#include "nvtxImplCore.h"
+
+/* ---- Define implementations of export table functions ---- */
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxEtiGetModuleFunctionTable)(
+    NvtxCallbackModule module,
+    NvtxFunctionTable* out_table,
+    unsigned int* out_size)
+{
+    unsigned int bytes = 0;
+    NvtxFunctionTable table = (NvtxFunctionTable)0;
+
+    switch (module)
+    {
+    case NVTX_CB_MODULE_CORE:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CORE;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CORE);
+        break;
+    case NVTX_CB_MODULE_CUDA:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CUDA;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CUDA);
+        break;
+    case NVTX_CB_MODULE_OPENCL:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_OPENCL;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_OPENCL);
+        break;
+    case NVTX_CB_MODULE_CUDART:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CUDART;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CUDART);
+        break;
+    case NVTX_CB_MODULE_CORE2:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CORE2;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_CORE2);
+        break;
+    case NVTX_CB_MODULE_SYNC:
+        table = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_SYNC;
+        bytes = (unsigned int)sizeof(NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).functionTable_SYNC);
+        break;
+    default: return 0;
+    }
+
+    if (out_size)
+        *out_size = (bytes / (unsigned int)sizeof(NvtxFunctionPointer*)) - 1;
+
+    if (out_table)
+        *out_table = table;
+
+    return 1;
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION const void* NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxGetExportTable)(uint32_t exportTableId)
+{
+    switch (exportTableId)
+    {
+    case NVTX_ETID_CALLBACKS:       return &NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).etblCallbacks;
+    case NVTX_ETID_VERSIONINFO:     return &NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).etblVersionInfo;
+    default:                        return 0;
+    }
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxEtiSetInjectionNvtxVersion)(uint32_t version)
+{
+    /* Reserved for custom implementations to resolve problems with tools */
+    (void)version;
+}
+
+/* ---- Define implementations of init versions of all API functions ---- */
+
+#include "nvtxInitDefs.h"
+
+/* ---- Define implementations of initialization functions ---- */
+
+#include "nvtxInit.h"
+
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCore.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCore.h
new file mode 100644
index 0000000000000000000000000000000000000000..aee1014ecd53f8b980442109e51fdbc7672ff6d0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCore.h
@@ -0,0 +1,299 @@
+NVTX_DECLSPEC void NVTX_API nvtxMarkEx(const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxMarkEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkEx_impl_fnptr;
+    if(local!=0)
+        (*local)(eventAttrib);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxMarkA(const char* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxMarkA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkA_impl_fnptr;
+    if(local!=0)
+        (*local)(message);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxMarkW(const wchar_t* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxMarkW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkW_impl_fnptr;
+    if(local!=0)
+        (*local)(message);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartEx(const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangeStartEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartEx_impl_fnptr;
+    if(local!=0)
+        return (*local)(eventAttrib);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxRangeId_t)0;
+}
+
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartA(const char* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangeStartA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartA_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxRangeId_t)0;
+}
+
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartW(const wchar_t* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangeStartW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartW_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxRangeId_t)0;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxRangeEnd(nvtxRangeId_t id)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangeEnd_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeEnd_impl_fnptr;
+    if(local!=0)
+        (*local)(id);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxRangePushEx(const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangePushEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushEx_impl_fnptr;
+    if(local!=0)
+        return (*local)(eventAttrib);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxRangePushA(const char* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangePushA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushA_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxRangePushW(const wchar_t* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangePushW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushW_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxRangePop(void)
+{
+#ifndef NVTX_DISABLE
+    nvtxRangePop_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePop_impl_fnptr;
+    if(local!=0)
+        return (*local)();
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCategoryA(uint32_t category, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCategoryA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryA_impl_fnptr;
+    if(local!=0)
+        (*local)(category, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCategoryW(uint32_t category, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCategoryW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryW_impl_fnptr;
+    if(local!=0)
+        (*local)(category, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadA(uint32_t threadId, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameOsThreadA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadA_impl_fnptr;
+    if(local!=0)
+        (*local)(threadId, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadW(uint32_t threadId, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameOsThreadW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadW_impl_fnptr;
+    if(local!=0)
+        (*local)(threadId, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainMarkEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainMarkEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainMarkEx_impl_fnptr;
+    if(local!=0)
+        (*local)(domain, eventAttrib);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxDomainRangeStartEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRangeStartEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeStartEx_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, eventAttrib);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxRangeId_t)0;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainRangeEnd(nvtxDomainHandle_t domain, nvtxRangeId_t id)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRangeEnd_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeEnd_impl_fnptr;
+    if(local!=0)
+        (*local)(domain, id);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxDomainRangePushEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRangePushEx_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePushEx_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, eventAttrib);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC int NVTX_API nvtxDomainRangePop(nvtxDomainHandle_t domain)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRangePop_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePop_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (int)NVTX_NO_PUSH_POP_TRACKING;
+}
+
+NVTX_DECLSPEC nvtxResourceHandle_t NVTX_API nvtxDomainResourceCreate(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainResourceCreate_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceCreate_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, attribs);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxResourceHandle_t)0;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainResourceDestroy(nvtxResourceHandle_t resource)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainResourceDestroy_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceDestroy_impl_fnptr;
+    if(local!=0)
+        (*local)(resource);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryA(nvtxDomainHandle_t domain, uint32_t category, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainNameCategoryA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryA_impl_fnptr;
+    if(local!=0)
+        (*local)(domain, category, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryW(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainNameCategoryW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryW_impl_fnptr;
+    if(local!=0)
+        (*local)(domain, category, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringA(nvtxDomainHandle_t domain, const char* string)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRegisterStringA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringA_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, string);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxStringHandle_t)0;
+}
+
+NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringW(nvtxDomainHandle_t domain, const wchar_t* string)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainRegisterStringW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringW_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, string);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxStringHandle_t)0;
+}
+
+NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateA(const char* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainCreateA_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateA_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxDomainHandle_t)0;
+}
+
+NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateW(const wchar_t* message)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainCreateW_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateW_impl_fnptr;
+    if(local!=0)
+        return (*local)(message);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxDomainHandle_t)0;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainDestroy(nvtxDomainHandle_t domain)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainDestroy_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainDestroy_impl_fnptr;
+    if(local!=0)
+        (*local)(domain);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxInitialize(const void* reserved)
+{
+#ifndef NVTX_DISABLE
+    nvtxInitialize_impl_fntype local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxInitialize_impl_fnptr;
+    if(local!=0)
+        (*local)(reserved);
+#endif /*NVTX_DISABLE*/
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCudaRt_v3.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCudaRt_v3.h
new file mode 100644
index 0000000000000000000000000000000000000000..24be8bd4722506d4ca318b07519884fc407847cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCudaRt_v3.h
@@ -0,0 +1,112 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD_CUDART
+#error Never include this file directly -- it is automatically included by nvToolsExtCudaRt.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+//typedef void (NVTX_API * nvtxNameCudaDeviceA_impl_fntype)(int device, const char* name);
+//typedef void (NVTX_API * nvtxNameCudaDeviceW_impl_fntype)(int device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCudaStreamA_impl_fntype)(cudaStream_t stream, const char* name);
+typedef void (NVTX_API * nvtxNameCudaStreamW_impl_fntype)(cudaStream_t stream, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCudaEventA_impl_fntype)(cudaEvent_t event, const char* name);
+typedef void (NVTX_API * nvtxNameCudaEventW_impl_fntype)(cudaEvent_t event, const wchar_t* name);
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaDeviceA(int device, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaDeviceA_impl_fntype local = (nvtxNameCudaDeviceA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceA_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaDeviceW(int device, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaDeviceW_impl_fntype local = (nvtxNameCudaDeviceW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceW_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaStreamA(cudaStream_t stream, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaStreamA_impl_fntype local = (nvtxNameCudaStreamA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamA_impl_fnptr;
+    if(local!=0)
+        (*local)(stream, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaStreamW(cudaStream_t stream, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaStreamW_impl_fntype local = (nvtxNameCudaStreamW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamW_impl_fnptr;
+    if(local!=0)
+        (*local)(stream, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaEventA(cudaEvent_t event, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaEventA_impl_fntype local = (nvtxNameCudaEventA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventA_impl_fnptr;
+    if(local!=0)
+        (*local)(event, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCudaEventW(cudaEvent_t event, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCudaEventW_impl_fntype local = (nvtxNameCudaEventW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventW_impl_fnptr;
+    if(local!=0)
+        (*local)(event, name);
+#endif /*NVTX_DISABLE*/
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCuda_v3.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCuda_v3.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee30111bd123b2c1706f23e73e3803b8c1a02927
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplCuda_v3.h
@@ -0,0 +1,133 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD_CUDA
+#error Never include this file directly -- it is automatically included by nvToolsExtCuda.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef void (NVTX_API * nvtxNameCuDeviceA_impl_fntype)(CUdevice device, const char* name);
+typedef void (NVTX_API * nvtxNameCuDeviceW_impl_fntype)(CUdevice device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuContextA_impl_fntype)(CUcontext context, const char* name);
+typedef void (NVTX_API * nvtxNameCuContextW_impl_fntype)(CUcontext context, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuStreamA_impl_fntype)(CUstream stream, const char* name);
+typedef void (NVTX_API * nvtxNameCuStreamW_impl_fntype)(CUstream stream, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuEventA_impl_fntype)(CUevent event, const char* name);
+typedef void (NVTX_API * nvtxNameCuEventW_impl_fntype)(CUevent event, const wchar_t* name);
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuDeviceA(CUdevice device, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuDeviceA_impl_fntype local = (nvtxNameCuDeviceA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceA_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuDeviceW(CUdevice device, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuDeviceW_impl_fntype local = (nvtxNameCuDeviceW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceW_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuContextA(CUcontext context, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuContextA_impl_fntype local = (nvtxNameCuContextA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextA_impl_fnptr;
+    if(local!=0)
+        (*local)(context, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuContextW(CUcontext context, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuContextW_impl_fntype local = (nvtxNameCuContextW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextW_impl_fnptr;
+    if(local!=0)
+        (*local)(context, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuStreamA(CUstream stream, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuStreamA_impl_fntype local = (nvtxNameCuStreamA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamA_impl_fnptr;
+    if(local!=0)
+        (*local)(stream, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuStreamW(CUstream stream, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuStreamW_impl_fntype local = (nvtxNameCuStreamW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamW_impl_fnptr;
+    if(local!=0)
+        (*local)(stream, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuEventA(CUevent event, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuEventA_impl_fntype local = (nvtxNameCuEventA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventA_impl_fnptr;
+    if(local!=0)
+        (*local)(event, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameCuEventW(CUevent event, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameCuEventW_impl_fntype local = (nvtxNameCuEventW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventW_impl_fnptr;
+    if(local!=0)
+        (*local)(event, name);
+#endif /*NVTX_DISABLE*/
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplOpenCL_v3.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplOpenCL_v3.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e73224cce26b49c8f7585be3a41dd0f428fe07e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplOpenCL_v3.h
@@ -0,0 +1,192 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD_OPENCL
+#error Never include this file directly -- it is automatically included by nvToolsExtCuda.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef void (NVTX_API * nvtxNameClDeviceA_impl_fntype)(cl_device_id device, const char* name);
+typedef void (NVTX_API * nvtxNameClDeviceW_impl_fntype)(cl_device_id device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClContextA_impl_fntype)(cl_context context, const char* name);
+typedef void (NVTX_API * nvtxNameClContextW_impl_fntype)(cl_context context, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClCommandQueueA_impl_fntype)(cl_command_queue command_queue, const char* name);
+typedef void (NVTX_API * nvtxNameClCommandQueueW_impl_fntype)(cl_command_queue command_queue, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClMemObjectA_impl_fntype)(cl_mem memobj, const char* name);
+typedef void (NVTX_API * nvtxNameClMemObjectW_impl_fntype)(cl_mem memobj, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClSamplerA_impl_fntype)(cl_sampler sampler, const char* name);
+typedef void (NVTX_API * nvtxNameClSamplerW_impl_fntype)(cl_sampler sampler, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClProgramA_impl_fntype)(cl_program program, const char* name);
+typedef void (NVTX_API * nvtxNameClProgramW_impl_fntype)(cl_program program, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClEventA_impl_fntype)(cl_event evnt, const char* name);
+typedef void (NVTX_API * nvtxNameClEventW_impl_fntype)(cl_event evnt, const wchar_t* name);
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClDeviceA(cl_device_id device, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClDeviceA_impl_fntype local = (nvtxNameClDeviceA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceA_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClDeviceW(cl_device_id device, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClDeviceW_impl_fntype local = (nvtxNameClDeviceW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceW_impl_fnptr;
+    if(local!=0)
+        (*local)(device, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClContextA(cl_context context, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClContextA_impl_fntype local = (nvtxNameClContextA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextA_impl_fnptr;
+    if(local!=0)
+        (*local)(context, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClContextW(cl_context context, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClContextW_impl_fntype local = (nvtxNameClContextW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextW_impl_fnptr;
+    if(local!=0)
+        (*local)(context, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClCommandQueueA(cl_command_queue command_queue, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClCommandQueueA_impl_fntype local = (nvtxNameClCommandQueueA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueA_impl_fnptr;
+    if(local!=0)
+        (*local)(command_queue, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClCommandQueueW(cl_command_queue command_queue, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClCommandQueueW_impl_fntype local = (nvtxNameClCommandQueueW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueW_impl_fnptr;
+    if(local!=0)
+        (*local)(command_queue, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClMemObjectA(cl_mem memobj, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClMemObjectA_impl_fntype local = (nvtxNameClMemObjectA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectA_impl_fnptr;
+    if(local!=0)
+        (*local)(memobj, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClMemObjectW(cl_mem memobj, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClMemObjectW_impl_fntype local = (nvtxNameClMemObjectW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectW_impl_fnptr;
+    if(local!=0)
+        (*local)(memobj, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClSamplerA(cl_sampler sampler, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClSamplerA_impl_fntype local = (nvtxNameClSamplerA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerA_impl_fnptr;
+    if(local!=0)
+        (*local)(sampler, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClSamplerW(cl_sampler sampler, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClSamplerW_impl_fntype local = (nvtxNameClSamplerW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerW_impl_fnptr;
+    if(local!=0)
+        (*local)(sampler, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClProgramA(cl_program program, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClProgramA_impl_fntype local = (nvtxNameClProgramA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramA_impl_fnptr;
+    if(local!=0)
+        (*local)(program, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClProgramW(cl_program program, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClProgramW_impl_fntype local = (nvtxNameClProgramW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramW_impl_fnptr;
+    if(local!=0)
+        (*local)(program, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClEventA(cl_event evnt, const char* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClEventA_impl_fntype local = (nvtxNameClEventA_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventA_impl_fnptr;
+    if(local!=0)
+        (*local)(evnt, name);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxNameClEventW(cl_event evnt, const wchar_t* name)
+{
+#ifndef NVTX_DISABLE
+    nvtxNameClEventW_impl_fntype local = (nvtxNameClEventW_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventW_impl_fnptr;
+    if(local!=0)
+        (*local)(evnt, name);
+#endif /*NVTX_DISABLE*/
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplSync_v3.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplSync_v3.h
new file mode 100644
index 0000000000000000000000000000000000000000..accc621a3d5071438f6ed7b9e2192ea8ad56977c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxImplSync_v3.h
@@ -0,0 +1,114 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD_SYNC
+#error Never include this file directly -- it is automatically included by nvToolsExtCuda.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef nvtxSyncUser_t (NVTX_API * nvtxDomainSyncUserCreate_impl_fntype)(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs);
+typedef void (NVTX_API * nvtxDomainSyncUserDestroy_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireStart_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireFailed_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireSuccess_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserReleasing_impl_fntype)(nvtxSyncUser_t handle);
+
+NVTX_DECLSPEC nvtxSyncUser_t NVTX_API nvtxDomainSyncUserCreate(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserCreate_impl_fntype local = (nvtxDomainSyncUserCreate_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserCreate_impl_fnptr;
+    if(local!=0)
+        return (*local)(domain, attribs);
+    else
+#endif  /*NVTX_DISABLE*/
+        return (nvtxSyncUser_t)0;
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserDestroy(nvtxSyncUser_t handle)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserDestroy_impl_fntype local = (nvtxDomainSyncUserDestroy_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserDestroy_impl_fnptr;
+    if(local!=0)
+        (*local)(handle);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireStart(nvtxSyncUser_t handle)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserAcquireStart_impl_fntype local = (nvtxDomainSyncUserAcquireStart_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireStart_impl_fnptr;
+    if(local!=0)
+        (*local)(handle);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireFailed(nvtxSyncUser_t handle)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserAcquireFailed_impl_fntype local = (nvtxDomainSyncUserAcquireFailed_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireFailed_impl_fnptr;
+    if(local!=0)
+        (*local)(handle);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserAcquireSuccess(nvtxSyncUser_t handle)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserAcquireSuccess_impl_fntype local = (nvtxDomainSyncUserAcquireSuccess_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireSuccess_impl_fnptr;
+    if(local!=0)
+        (*local)(handle);
+#endif /*NVTX_DISABLE*/
+}
+
+NVTX_DECLSPEC void NVTX_API nvtxDomainSyncUserReleasing(nvtxSyncUser_t handle)
+{
+#ifndef NVTX_DISABLE
+    nvtxDomainSyncUserReleasing_impl_fntype local = (nvtxDomainSyncUserReleasing_impl_fntype)NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserReleasing_impl_fnptr;
+    if(local!=0)
+        (*local)(handle);
+#endif /*NVTX_DISABLE*/
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInit.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInit.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2bbd3a120da351f1ad1d81dde6bfb46244559cc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInit.h
@@ -0,0 +1,343 @@
+/* This file was procedurally generated!  Do not modify this file by hand.  */
+
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+#ifndef NVTX_IMPL_GUARD
+#error Never include this file directly -- it is automatically included by nvToolsExt.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+/* ---- Platform-independent helper definitions and functions ---- */
+
+/* Prefer macros over inline functions to reduce symbol resolution at link time */
+
+#if defined(_WIN32) 
+#define NVTX_PATHCHAR   wchar_t
+#define NVTX_STR(x)     L##x
+#define NVTX_GETENV     _wgetenv
+#define NVTX_BUFSIZE    MAX_PATH
+#define NVTX_DLLHANDLE  HMODULE
+#define NVTX_DLLOPEN(x) LoadLibraryW(x)
+#define NVTX_DLLFUNC    GetProcAddress
+#define NVTX_DLLCLOSE   FreeLibrary
+#define NVTX_YIELD()    SwitchToThread()
+#define NVTX_MEMBAR()   MemoryBarrier()
+#define NVTX_ATOMIC_WRITE_32(address, value)                        InterlockedExchange((volatile LONG*)address, value)
+#define NVTX_ATOMIC_CAS_32(old, address, exchange, comparand) old = InterlockedCompareExchange((volatile LONG*)address, exchange, comparand)
+#elif defined(__GNUC__)
+#define NVTX_PATHCHAR   char
+#define NVTX_STR(x)     x
+#define NVTX_GETENV     getenv
+#define NVTX_BUFSIZE    PATH_MAX
+#define NVTX_DLLHANDLE  void*
+#define NVTX_DLLOPEN(x) dlopen(x, RTLD_LAZY)
+#define NVTX_DLLFUNC    dlsym
+#define NVTX_DLLCLOSE   dlclose
+#define NVTX_YIELD()    sched_yield()
+#define NVTX_MEMBAR()   __sync_synchronize()
+/* Ensure full memory barrier for atomics, to match Windows functions */
+#define NVTX_ATOMIC_WRITE_32(address, value)                  __sync_synchronize();       __sync_lock_test_and_set(address, value)
+#define NVTX_ATOMIC_CAS_32(old, address, exchange, comparand) __sync_synchronize(); old = __sync_val_compare_and_swap(address, exchange, comparand)
+#else
+#error The library does not support your configuration!
+#endif
+
+/* Define this to 1 for platforms that where pre-injected libraries can be discovered. */
+#if defined(_WIN32)
+/* TODO */
+#define NVTX_SUPPORT_ALREADY_INJECTED_LIBRARY 0
+#else
+#define NVTX_SUPPORT_ALREADY_INJECTED_LIBRARY 0
+#endif
+
+/* Define this to 1 for platforms that support environment variables */
+/* TODO: Detect UWP, a.k.a. Windows Store app, and set this to 0. */
+/* Try:  #if defined(WINAPI_FAMILY_PARTITION) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
+#define NVTX_SUPPORT_ENV_VARS 1
+
+/* Define this to 1 for platforms that support dynamic/shared libraries */
+#define NVTX_SUPPORT_DYNAMIC_INJECTION_LIBRARY 1
+
+/* Injection libraries implementing InitializeInjectionNvtx2 may be statically linked,
+*  and this will override any dynamic injection.  Useful for platforms where dynamic
+*  injection is not available.  Since weak symbols not explicitly marked extern are
+*  guaranteed to be initialized to zero if no definitions are found by the linker, the
+*  dynamic injection process proceeds normally if pfnInitializeInjectionNvtx2 is 0. */
+#if defined(__GNUC__) && !defined(_WIN32) && !defined(__CYGWIN__)
+#define NVTX_SUPPORT_STATIC_INJECTION_LIBRARY 1
+/* To statically inject an NVTX library, define InitializeInjectionNvtx2_fnptr as a normal
+*  symbol (not weak) pointing to the implementation of InitializeInjectionNvtx2 (which
+*  does not need to be named "InitializeInjectionNvtx2" as is necessary in a dynamic
+*  injection library. */
+__attribute__((weak)) NvtxInitializeInjectionNvtxFunc_t InitializeInjectionNvtx2_fnptr;
+#else
+#define NVTX_SUPPORT_STATIC_INJECTION_LIBRARY 0
+#endif
+
+/* This function tries to find or load an NVTX injection library and get the
+*  address of its InitializeInjection2 function.  If such a function pointer
+*  is found, it is called, and passed the address of this NVTX instance's
+*  nvtxGetExportTable function, so the injection can attach to this instance.
+*  If the initialization fails for any reason, any dynamic library loaded will
+*  be freed, and all NVTX implementation functions will be set to no-ops.  If
+*  initialization succeeds, NVTX functions not attached to the tool will be set
+*  to no-ops.  This is implemented as one function instead of several small
+*  functions to minimize the number of weak symbols the linker must resolve.
+*  Order of search is:
+*  - Pre-injected library exporting InitializeInjectionNvtx2
+*  - Loadable library exporting InitializeInjectionNvtx2
+*      - Path specified by env var NVTX_INJECTION??_PATH (?? is 32 or 64)
+*      - On Android, libNvtxInjection??.so within the package (?? is 32 or 64)
+*  - Statically-linked injection library defining InitializeInjectionNvtx2_fnptr
+*/
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_VERSIONED_IDENTIFIER(nvtxInitializeInjectionLibrary)(void);
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_VERSIONED_IDENTIFIER(nvtxInitializeInjectionLibrary)(void)
+{
+    const char* const initFuncName = "InitializeInjectionNvtx2";
+    NvtxInitializeInjectionNvtxFunc_t init_fnptr = (NvtxInitializeInjectionNvtxFunc_t)0;
+    NVTX_DLLHANDLE injectionLibraryHandle = (NVTX_DLLHANDLE)0;
+    int entryPointStatus = 0;
+
+#if NVTX_SUPPORT_ALREADY_INJECTED_LIBRARY
+    /* Use POSIX global symbol chain to query for init function from any module */
+    init_fnptr = (NvtxInitializeInjectionNvtxFunc_t)NVTX_DLLFUNC(0, initFuncName);
+#endif
+
+#if NVTX_SUPPORT_DYNAMIC_INJECTION_LIBRARY
+    /* Try discovering dynamic injection library to load */
+    if (!init_fnptr)
+    {
+#if NVTX_SUPPORT_ENV_VARS
+        /* If env var NVTX_INJECTION64_PATH is set, it should contain the path
+        *  to a 64-bit dynamic NVTX injection library (and similar for 32-bit). */
+        const NVTX_PATHCHAR* const nvtxEnvVarName = (sizeof(void*) == 4)
+            ? NVTX_STR("NVTX_INJECTION32_PATH")
+            : NVTX_STR("NVTX_INJECTION64_PATH");
+#endif /* NVTX_SUPPORT_ENV_VARS */
+        NVTX_PATHCHAR injectionLibraryPathBuf[NVTX_BUFSIZE];
+        const NVTX_PATHCHAR* injectionLibraryPath = (const NVTX_PATHCHAR*)0;
+
+        /* Refer to this variable explicitly in case all references to it are #if'ed out */
+        (void)injectionLibraryPathBuf;
+
+#if NVTX_SUPPORT_ENV_VARS
+        /* Disable the warning for getenv & _wgetenv -- this usage is safe because
+        *  these functions are not called again before using the returned value. */
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4996 )
+#endif
+        injectionLibraryPath = NVTX_GETENV(nvtxEnvVarName);
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+#endif
+
+#if defined(__ANDROID__)
+        if (!injectionLibraryPath)
+        {
+            const char *bits = (sizeof(void*) == 4) ? "32" : "64";
+            char cmdlineBuf[32];
+            char pkgName[PATH_MAX];
+            int count;
+            int pid;
+            FILE *fp;
+            size_t bytesRead;
+            size_t pos;
+
+            pid = (int)getpid();
+            count = snprintf(cmdlineBuf, sizeof(cmdlineBuf), "/proc/%d/cmdline", pid);
+            if (count <= 0 || count >= (int)sizeof(cmdlineBuf))
+            {
+                NVTX_ERR("Path buffer too small for: /proc/%d/cmdline\n", pid);
+                return NVTX_ERR_INIT_ACCESS_LIBRARY;
+            }
+
+            fp = fopen(cmdlineBuf, "r");
+            if (!fp)
+            {
+                NVTX_ERR("File couldn't be opened: %s\n", cmdlineBuf);
+                return NVTX_ERR_INIT_ACCESS_LIBRARY;
+            }
+
+            bytesRead = fread(pkgName, 1, sizeof(pkgName) - 1, fp);
+            fclose(fp);
+            if (bytesRead == 0)
+            {
+                NVTX_ERR("Package name couldn't be read from file: %s\n", cmdlineBuf);
+                return NVTX_ERR_INIT_ACCESS_LIBRARY;
+            }
+
+            pkgName[bytesRead] = 0;
+
+            /* String can contain colon as a process separator. In this case the package name is before the colon. */
+            pos = 0;
+            while (pos < bytesRead && pkgName[pos] != ':' && pkgName[pos] != '\0')
+            {
+                ++pos;
+            }
+            pkgName[pos] = 0;
+
+            count = snprintf(injectionLibraryPathBuf, NVTX_BUFSIZE, "/data/data/%s/files/libNvtxInjection%s.so", pkgName, bits);
+            if (count <= 0 || count >= NVTX_BUFSIZE)
+            {
+                NVTX_ERR("Path buffer too small for: /data/data/%s/files/libNvtxInjection%s.so\n", pkgName, bits);
+                return NVTX_ERR_INIT_ACCESS_LIBRARY;
+            }
+
+            /* On Android, verify path is accessible due to aggressive file access restrictions. */
+            /* For dlopen, if the filename contains a leading slash, then it is interpreted as a */
+            /* relative or absolute pathname; otherwise it will follow the rules in ld.so. */
+            if (injectionLibraryPathBuf[0] == '/')
+            {
+#if (__ANDROID_API__ < 21)
+                int access_err = access(injectionLibraryPathBuf, F_OK | R_OK);
+#else
+                int access_err = faccessat(AT_FDCWD, injectionLibraryPathBuf, F_OK | R_OK, 0);
+#endif
+                if (access_err != 0)
+                {
+                    NVTX_ERR("Injection library path wasn't accessible [code=%s] [path=%s]\n", strerror(errno), injectionLibraryPathBuf);
+                    return NVTX_ERR_INIT_ACCESS_LIBRARY;
+                }
+            }
+            injectionLibraryPath = injectionLibraryPathBuf;
+        }
+#endif
+
+        /* At this point, injectionLibraryPath is specified if a dynamic
+        *  injection library was specified by a tool. */
+        if (injectionLibraryPath)
+        {
+            /* Load the injection library */
+            injectionLibraryHandle = NVTX_DLLOPEN(injectionLibraryPath);
+            if (!injectionLibraryHandle)
+            {
+                NVTX_ERR("Failed to load injection library\n");
+                return NVTX_ERR_INIT_LOAD_LIBRARY;
+            }
+            else
+            {
+                /* Attempt to get the injection library's entry-point */
+                init_fnptr = (NvtxInitializeInjectionNvtxFunc_t)NVTX_DLLFUNC(injectionLibraryHandle, initFuncName);
+                if (!init_fnptr)
+                {
+                    NVTX_DLLCLOSE(injectionLibraryHandle);
+                    NVTX_ERR("Failed to get address of function InitializeInjectionNvtx2 from injection library\n");
+                    return NVTX_ERR_INIT_MISSING_LIBRARY_ENTRY_POINT;
+                }
+            }
+        }
+    }
+#endif
+
+#if NVTX_SUPPORT_STATIC_INJECTION_LIBRARY
+    if (!init_fnptr)
+    {
+        /* Check weakly-defined function pointer.  A statically-linked injection can define this as
+        *  a normal symbol and it will take precedence over a dynamic injection. */
+        if (InitializeInjectionNvtx2_fnptr)
+        {
+            init_fnptr = InitializeInjectionNvtx2_fnptr;
+        }
+    }
+#endif
+
+    /* At this point, if init_fnptr is not set, then no tool has specified
+    *  an NVTX injection library -- return non-success result so all NVTX
+    *  API functions will be set to no-ops. */
+    if (!init_fnptr)
+    {
+        return NVTX_ERR_NO_INJECTION_LIBRARY_AVAILABLE;
+    }
+
+    /* Invoke injection library's initialization function.  If it returns
+    *  0 (failure) and a dynamic injection was loaded, unload it. */
+    entryPointStatus = init_fnptr(NVTX_VERSIONED_IDENTIFIER(nvtxGetExportTable));
+    if (entryPointStatus == 0)
+    {
+        NVTX_ERR("Failed to initialize injection library -- initialization function returned 0\n");
+        if (injectionLibraryHandle)
+        {
+            NVTX_DLLCLOSE(injectionLibraryHandle);
+        }
+        return NVTX_ERR_INIT_FAILED_LIBRARY_ENTRY_POINT;
+    }
+
+    return NVTX_SUCCESS;
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)(void)
+{
+    unsigned int old;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).initState == NVTX_INIT_STATE_COMPLETE)
+    {
+        return;
+    }
+
+    NVTX_ATOMIC_CAS_32(
+        old,
+        &NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).initState,
+        NVTX_INIT_STATE_STARTED,
+        NVTX_INIT_STATE_FRESH);
+    if (old == NVTX_INIT_STATE_FRESH)
+    {
+        int result;
+        int forceAllToNoops;
+
+        /* Load & initialize injection library -- it will assign the function pointers */
+        result = NVTX_VERSIONED_IDENTIFIER(nvtxInitializeInjectionLibrary)();
+
+        /* Set all pointers not assigned by the injection to null */
+        forceAllToNoops = result != NVTX_SUCCESS; /* Set all to null if injection init failed */
+        NVTX_VERSIONED_IDENTIFIER(nvtxSetInitFunctionsToNoops)(forceAllToNoops);
+
+        /* Signal that initialization has finished, so now the assigned function pointers will be used */
+        NVTX_ATOMIC_WRITE_32(
+            &NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).initState,
+            NVTX_INIT_STATE_COMPLETE);
+    }
+    else /* Spin-wait until initialization has finished */
+    {
+        NVTX_MEMBAR();
+        while (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).initState != NVTX_INIT_STATE_COMPLETE)
+        {
+            NVTX_YIELD();
+            NVTX_MEMBAR();
+        }
+    }
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDecls.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDecls.h
new file mode 100644
index 0000000000000000000000000000000000000000..757a7296093750e75721fb93855d0aa37da64103
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDecls.h
@@ -0,0 +1,73 @@
+#ifndef NVTX_IMPL_GUARD
+#error Never include this file directly -- it is automatically included by nvToolsExt.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkEx_impl_init)(const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkA_impl_init)(const char* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkW_impl_init)(const wchar_t* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartEx_impl_init)(const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartA_impl_init)(const char* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartW_impl_init)(const wchar_t* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeEnd_impl_init)(nvtxRangeId_t id);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushEx_impl_init)(const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushA_impl_init)(const char* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushW_impl_init)(const wchar_t* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePop_impl_init)(void);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryA_impl_init)(uint32_t category, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryW_impl_init)(uint32_t category, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadA_impl_init)(uint32_t threadId, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadW_impl_init)(uint32_t threadId, const wchar_t* name);
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceA_impl_init)(nvtx_CUdevice device, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceW_impl_init)(nvtx_CUdevice device, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextA_impl_init)(nvtx_CUcontext context, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextW_impl_init)(nvtx_CUcontext context, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamA_impl_init)(nvtx_CUstream stream, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamW_impl_init)(nvtx_CUstream stream, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventA_impl_init)(nvtx_CUevent event, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventW_impl_init)(nvtx_CUevent event, const wchar_t* name);
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceA_impl_init)(nvtx_cl_device_id device, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceW_impl_init)(nvtx_cl_device_id device, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextA_impl_init)(nvtx_cl_context context, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextW_impl_init)(nvtx_cl_context context, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueA_impl_init)(nvtx_cl_command_queue command_queue, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueW_impl_init)(nvtx_cl_command_queue command_queue, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectA_impl_init)(nvtx_cl_mem memobj, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectW_impl_init)(nvtx_cl_mem memobj, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerA_impl_init)(nvtx_cl_sampler sampler, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerW_impl_init)(nvtx_cl_sampler sampler, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramA_impl_init)(nvtx_cl_program program, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramW_impl_init)(nvtx_cl_program program, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventA_impl_init)(nvtx_cl_event evnt, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventW_impl_init)(nvtx_cl_event evnt, const wchar_t* name);
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceA_impl_init)(int device, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceW_impl_init)(int device, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamA_impl_init)(nvtx_cudaStream_t stream, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamW_impl_init)(nvtx_cudaStream_t stream, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventA_impl_init)(nvtx_cudaEvent_t event, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventW_impl_init)(nvtx_cudaEvent_t event, const wchar_t* name);
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainMarkEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeStartEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeEnd_impl_init)(nvtxDomainHandle_t domain, nvtxRangeId_t id);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePushEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+NVTX_LINKONCE_FWDDECL_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePop_impl_init)(nvtxDomainHandle_t domain);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxResourceHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceCreate_impl_init)(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceDestroy_impl_init)(nvtxResourceHandle_t resource);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryA_impl_init)(nvtxDomainHandle_t domain, uint32_t category, const char* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryW_impl_init)(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxStringHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringA_impl_init)(nvtxDomainHandle_t domain, const char* string);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxStringHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringW_impl_init)(nvtxDomainHandle_t domain, const wchar_t* string);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxDomainHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateA_impl_init)(const char* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxDomainHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateW_impl_init)(const wchar_t* message);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainDestroy_impl_init)(nvtxDomainHandle_t domain);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxInitialize_impl_init)(const void* reserved);
+
+NVTX_LINKONCE_FWDDECL_FUNCTION nvtxSyncUser_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserCreate_impl_init)(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserDestroy_impl_init)(nvtxSyncUser_t handle);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireStart_impl_init)(nvtxSyncUser_t handle);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireFailed_impl_init)(nvtxSyncUser_t handle);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireSuccess_impl_init)(nvtxSyncUser_t handle);
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserReleasing_impl_init)(nvtxSyncUser_t handle);
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDefs.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..93d5f0e975059b00f8fb32d95ab06483cc53d80e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxInitDefs.h
@@ -0,0 +1,565 @@
+#ifndef NVTX_IMPL_GUARD
+#error Never include this file directly -- it is automatically included by nvToolsExt.h (except when NVTX_NO_IMPL is defined).
+#endif
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkEx_impl_init)(const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxMarkEx(eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkA_impl_init)(const char* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxMarkA(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxMarkW_impl_init)(const wchar_t* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxMarkW(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartEx_impl_init)(const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangeStartEx(eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartA_impl_init)(const char* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangeStartA(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartW_impl_init)(const wchar_t* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangeStartW(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangeEnd_impl_init)(nvtxRangeId_t id){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxRangeEnd(id);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushEx_impl_init)(const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangePushEx(eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushA_impl_init)(const char* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangePushA(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePushW_impl_init)(const wchar_t* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangePushW(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxRangePop_impl_init)(void){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxRangePop();
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryA_impl_init)(uint32_t category, const char* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxNameCategoryA(category, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryW_impl_init)(uint32_t category, const wchar_t* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxNameCategoryW(category, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadA_impl_init)(uint32_t threadId, const char* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxNameOsThreadA(threadId, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadW_impl_init)(uint32_t threadId, const wchar_t* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxNameOsThreadW(threadId, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainMarkEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainMarkEx(domain, eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxRangeId_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeStartEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainRangeStartEx(domain, eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeEnd_impl_init)(nvtxDomainHandle_t domain, nvtxRangeId_t id){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainRangeEnd(domain, id);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePushEx_impl_init)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainRangePushEx(domain, eventAttrib);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION int NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePop_impl_init)(nvtxDomainHandle_t domain){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainRangePop(domain);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxResourceHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceCreate_impl_init)(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainResourceCreate(domain, attribs);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceDestroy_impl_init)(nvtxResourceHandle_t resource){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainResourceDestroy(resource);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryA_impl_init)(nvtxDomainHandle_t domain, uint32_t category, const char* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainNameCategoryA(domain, category, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryW_impl_init)(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainNameCategoryW(domain, category, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxStringHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringA_impl_init)(nvtxDomainHandle_t domain, const char* string){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainRegisterStringA(domain, string);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxStringHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringW_impl_init)(nvtxDomainHandle_t domain, const wchar_t* string){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainRegisterStringW(domain, string);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxDomainHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateA_impl_init)(const char* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainCreateA(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxDomainHandle_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateW_impl_init)(const wchar_t* message){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    return nvtxDomainCreateW(message);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainDestroy_impl_init)(nvtxDomainHandle_t domain){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxDomainDestroy(domain);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxInitialize_impl_init)(const void* reserved){
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    nvtxInitialize(reserved);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceA_impl_init)(nvtx_CUdevice device, const char* name){
+    nvtxNameCuDeviceA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceA_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceW_impl_init)(nvtx_CUdevice device, const wchar_t* name){
+    nvtxNameCuDeviceW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceW_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextA_impl_init)(nvtx_CUcontext context, const char* name){
+    nvtxNameCuContextA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextA_impl_fnptr;
+    if (local)
+        local(context, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextW_impl_init)(nvtx_CUcontext context, const wchar_t* name){
+    nvtxNameCuContextW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextW_impl_fnptr;
+    if (local)
+        local(context, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamA_impl_init)(nvtx_CUstream stream, const char* name){
+    nvtxNameCuStreamA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamA_impl_fnptr;
+    if (local)
+        local(stream, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamW_impl_init)(nvtx_CUstream stream, const wchar_t* name){
+    nvtxNameCuStreamW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamW_impl_fnptr;
+    if (local)
+        local(stream, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventA_impl_init)(nvtx_CUevent event, const char* name){
+    nvtxNameCuEventA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventA_impl_fnptr;
+    if (local)
+        local(event, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventW_impl_init)(nvtx_CUevent event, const wchar_t* name){
+    nvtxNameCuEventW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventW_impl_fnptr;
+    if (local)
+        local(event, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceA_impl_init)(int device, const char* name){
+    nvtxNameCudaDeviceA_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceA_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceW_impl_init)(int device, const wchar_t* name){
+    nvtxNameCudaDeviceW_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceW_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamA_impl_init)(nvtx_cudaStream_t stream, const char* name){
+    nvtxNameCudaStreamA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamA_impl_fnptr;
+    if (local)
+        local(stream, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamW_impl_init)(nvtx_cudaStream_t stream, const wchar_t* name){
+    nvtxNameCudaStreamW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamW_impl_fnptr;
+    if (local)
+        local(stream, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventA_impl_init)(nvtx_cudaEvent_t event, const char* name){
+    nvtxNameCudaEventA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventA_impl_fnptr;
+    if (local)
+        local(event, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventW_impl_init)(nvtx_cudaEvent_t event, const wchar_t* name){
+    nvtxNameCudaEventW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventW_impl_fnptr;
+    if (local)
+        local(event, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceA_impl_init)(nvtx_cl_device_id device, const char* name){
+    nvtxNameClDeviceA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceA_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceW_impl_init)(nvtx_cl_device_id device, const wchar_t* name){
+    nvtxNameClDeviceW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceW_impl_fnptr;
+    if (local)
+        local(device, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextA_impl_init)(nvtx_cl_context context, const char* name){
+    nvtxNameClContextA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextA_impl_fnptr;
+    if (local)
+        local(context, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextW_impl_init)(nvtx_cl_context context, const wchar_t* name){
+    nvtxNameClContextW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextW_impl_fnptr;
+    if (local)
+        local(context, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueA_impl_init)(nvtx_cl_command_queue command_queue, const char* name){
+    nvtxNameClCommandQueueA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueA_impl_fnptr;
+    if (local)
+        local(command_queue, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueW_impl_init)(nvtx_cl_command_queue command_queue, const wchar_t* name){
+    nvtxNameClCommandQueueW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueW_impl_fnptr;
+    if (local)
+        local(command_queue, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectA_impl_init)(nvtx_cl_mem memobj, const char* name){
+    nvtxNameClMemObjectA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectA_impl_fnptr;
+    if (local)
+        local(memobj, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectW_impl_init)(nvtx_cl_mem memobj, const wchar_t* name){
+    nvtxNameClMemObjectW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectW_impl_fnptr;
+    if (local)
+        local(memobj, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerA_impl_init)(nvtx_cl_sampler sampler, const char* name){
+    nvtxNameClSamplerA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerA_impl_fnptr;
+    if (local)
+        local(sampler, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerW_impl_init)(nvtx_cl_sampler sampler, const wchar_t* name){
+    nvtxNameClSamplerW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerW_impl_fnptr;
+    if (local)
+        local(sampler, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramA_impl_init)(nvtx_cl_program program, const char* name){
+    nvtxNameClProgramA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramA_impl_fnptr;
+    if (local)
+        local(program, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramW_impl_init)(nvtx_cl_program program, const wchar_t* name){
+    nvtxNameClProgramW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramW_impl_fnptr;
+    if (local)
+        local(program, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventA_impl_init)(nvtx_cl_event evnt, const char* name){
+    nvtxNameClEventA_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventA_impl_fnptr;
+    if (local)
+        local(evnt, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventW_impl_init)(nvtx_cl_event evnt, const wchar_t* name){
+    nvtxNameClEventW_fakeimpl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventW_impl_fnptr;
+    if (local)
+        local(evnt, name);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION nvtxSyncUser_t NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserCreate_impl_init)(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs){
+    nvtxDomainSyncUserCreate_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserCreate_impl_fnptr;
+    if (local) {
+        return local(domain, attribs);
+    }
+    return (nvtxSyncUser_t)0;
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserDestroy_impl_init)(nvtxSyncUser_t handle){
+    nvtxDomainSyncUserDestroy_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserDestroy_impl_fnptr;
+    if (local)
+        local(handle);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireStart_impl_init)(nvtxSyncUser_t handle){
+    nvtxDomainSyncUserAcquireStart_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireStart_impl_fnptr;
+    if (local)
+        local(handle);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireFailed_impl_init)(nvtxSyncUser_t handle){
+    nvtxDomainSyncUserAcquireFailed_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireFailed_impl_fnptr;
+    if (local)
+        local(handle);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireSuccess_impl_init)(nvtxSyncUser_t handle){
+    nvtxDomainSyncUserAcquireSuccess_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireSuccess_impl_fnptr;
+    if (local)
+        local(handle);
+}
+
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_API NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserReleasing_impl_init)(nvtxSyncUser_t handle){
+    nvtxDomainSyncUserReleasing_impl_fntype local;
+    NVTX_VERSIONED_IDENTIFIER(nvtxInitOnce)();
+    local = NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserReleasing_impl_fnptr;
+    if (local)
+        local(handle);
+}
+
+NVTX_LINKONCE_FWDDECL_FUNCTION void NVTX_VERSIONED_IDENTIFIER(nvtxSetInitFunctionsToNoops)(int forceAllToNoops);
+NVTX_LINKONCE_DEFINE_FUNCTION void NVTX_VERSIONED_IDENTIFIER(nvtxSetInitFunctionsToNoops)(int forceAllToNoops)
+{
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxMarkEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxMarkA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxMarkW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxMarkW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangeStartW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeStartW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeEnd_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangeEnd_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangeEnd_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangePushEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangePushA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangePushW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePushW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePop_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxRangePop_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxRangePop_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCategoryW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCategoryW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameOsThreadW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameOsThreadW_impl_fnptr = NULL;
+
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuDeviceW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuDeviceW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuContextW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuContextW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuStreamW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuStreamW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCuEventW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCuEventW_impl_fnptr = NULL;
+
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClDeviceW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClDeviceW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClContextW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClContextW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClCommandQueueW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClCommandQueueW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClMemObjectW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClMemObjectW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClSamplerW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClSamplerW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClProgramW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClProgramW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameClEventW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameClEventW_impl_fnptr = NULL;
+
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaDeviceW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaDeviceW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaStreamW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaStreamW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxNameCudaEventW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxNameCudaEventW_impl_fnptr = NULL;
+
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainMarkEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainMarkEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainMarkEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeStartEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeStartEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeStartEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeEnd_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangeEnd_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangeEnd_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePushEx_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePushEx_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePushEx_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePop_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRangePop_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRangePop_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceCreate_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceCreate_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceCreate_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceDestroy_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainResourceDestroy_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainResourceDestroy_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainNameCategoryW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainNameCategoryW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainRegisterStringW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainRegisterStringW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateA_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateA_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateA_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateW_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainCreateW_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainCreateW_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainDestroy_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainDestroy_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainDestroy_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxInitialize_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxInitialize_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxInitialize_impl_fnptr = NULL;
+
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserCreate_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserCreate_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserCreate_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserDestroy_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserDestroy_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserDestroy_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireStart_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireStart_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireStart_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireFailed_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireFailed_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireFailed_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireSuccess_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserAcquireSuccess_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserAcquireSuccess_impl_fnptr = NULL;
+    if (NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserReleasing_impl_fnptr == NVTX_VERSIONED_IDENTIFIER(nvtxDomainSyncUserReleasing_impl_init) || forceAllToNoops)
+        NVTX_VERSIONED_IDENTIFIER(nvtxGlobals).nvtxDomainSyncUserReleasing_impl_fnptr = NULL;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxLinkOnce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxLinkOnce.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c6eaa732464519fc7d93f98b646729dab0db8b9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxLinkOnce.h
@@ -0,0 +1,75 @@
+#ifndef __NVTX_LINKONCE_H__
+#define __NVTX_LINKONCE_H__
+
+/* This header defines macros to permit making definitions of global variables
+ * and functions in C/C++ header files which may be included multiple times in
+ * a translation unit or linkage unit.  It allows authoring header-only libraries
+ * which can be used by multiple other header-only libraries (either as the same
+ * copy or multiple copies), and does not require any build changes, such as
+ * adding another .c file, linking a static library, or deploying a dynamic
+ * library.  Globals defined with these macros have the property that they have
+ * the same address, pointing to a single instance, for the entire linkage unit.
+ * It is expected but not guaranteed that each linkage unit will have a separate
+ * instance.
+ *
+ * In some situations it is desirable to declare a variable without initializing
+ * it, refer to it in code or other variables' initializers, and then initialize
+ * it later.  Similarly, functions can be prototyped, have their address taken,
+ * and then have their body defined later.  In such cases, use the FWDDECL macros 
+ * when forward-declaring LINKONCE global variables without initializers and
+ * function prototypes, and then use the DEFINE macros when later defining them.
+ * Although in many cases the FWDDECL macro is equivalent to the DEFINE macro,
+ * following this pattern makes code maximally portable.
+ */
+
+#if defined(__MINGW32__) /* MinGW */
+    #define NVTX_LINKONCE_WEAK __attribute__((section(".gnu.linkonce.0.")))
+    #if defined(__cplusplus)
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   __declspec(selectany)
+        #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" inline NVTX_LINKONCE_WEAK
+    #else
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   __declspec(selectany)
+        #define NVTX_LINKONCE_DEFINE_FUNCTION NVTX_LINKONCE_WEAK
+    #endif
+#elif defined(_MSC_VER) /* MSVC */
+    #if defined(__cplusplus)
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   extern "C" __declspec(selectany)
+        #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" inline
+    #else
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   __declspec(selectany)
+        #define NVTX_LINKONCE_DEFINE_FUNCTION __inline
+    #endif
+#elif defined(__CYGWIN__) && defined(__clang__) /* Clang on Cygwin */
+    #define NVTX_LINKONCE_WEAK __attribute__((section(".gnu.linkonce.0.")))
+    #if defined(__cplusplus)
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   NVTX_LINKONCE_WEAK
+        #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" NVTX_LINKONCE_WEAK
+    #else
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   NVTX_LINKONCE_WEAK
+        #define NVTX_LINKONCE_DEFINE_FUNCTION NVTX_LINKONCE_WEAK
+    #endif
+#elif defined(__CYGWIN__) /* Assume GCC or compatible */
+    #define NVTX_LINKONCE_WEAK __attribute__((weak))
+    #if defined(__cplusplus)
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   __declspec(selectany)
+        #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" inline
+    #else
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   NVTX_LINKONCE_WEAK
+        #define NVTX_LINKONCE_DEFINE_FUNCTION NVTX_LINKONCE_WEAK
+    #endif
+#else /* All others: Assume GCC, clang, or compatible */
+    #define NVTX_LINKONCE_WEAK   __attribute__((weak))
+    #define NVTX_LINKONCE_HIDDEN __attribute__((visibility("hidden")))
+    #if defined(__cplusplus)
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK
+        #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" NVTX_LINKONCE_HIDDEN inline
+    #else
+        #define NVTX_LINKONCE_DEFINE_GLOBAL   NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK
+        #define NVTX_LINKONCE_DEFINE_FUNCTION NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK
+    #endif
+#endif
+
+#define NVTX_LINKONCE_FWDDECL_GLOBAL   NVTX_LINKONCE_DEFINE_GLOBAL   extern
+#define NVTX_LINKONCE_FWDDECL_FUNCTION NVTX_LINKONCE_DEFINE_FUNCTION
+
+#endif /* __NVTX_LINKONCE_H__ */
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxTypes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxTypes.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ddb1a9b3baff99c78b1c9acc06ac0eb64de8d6d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/nvtx3/nvtxDetail/nvtxTypes.h
@@ -0,0 +1,333 @@
+/*
+* Copyright 2009-2016  NVIDIA Corporation.  All rights reserved.
+*
+* NOTICE TO USER:
+*
+* This source code is subject to NVIDIA ownership rights under U.S. and
+* international Copyright laws.
+*
+* This software and the information contained herein is PROPRIETARY and
+* CONFIDENTIAL to NVIDIA and is being provided under the terms and conditions
+* of a form of NVIDIA software license agreement.
+*
+* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+* CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+* IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
+* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+* OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+* OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+* OR PERFORMANCE OF THIS SOURCE CODE.
+*
+* U.S. Government End Users.   This source code is a "commercial item" as
+* that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+* "commercial computer  software"  and "commercial computer software
+* documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+* and is provided to the U.S. Government only as a commercial end item.
+* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+* source code with only those rights set forth herein.
+*
+* Any use of this source code in individual and commercial software must
+* include, in the user documentation and internal comments to the code,
+* the above Disclaimer and U.S. Government End Users Notice.
+*/
+
+/* This header defines types which are used by the internal implementation
+*  of NVTX and callback subscribers.  API clients do not use these types,
+*  so they are defined here instead of in nvToolsExt.h to clarify they are
+*  not part of the NVTX client API. */
+
+#ifndef NVTX_IMPL_GUARD
+#error Never include this file directly -- it is automatically included by nvToolsExt.h.
+#endif
+
+/* ------ Dependency-free types binary-compatible with real types ------- */
+
+/* In order to avoid having the NVTX core API headers depend on non-NVTX
+*  headers like cuda.h, NVTX defines binary-compatible types to use for
+*  safely making the initialization versions of all NVTX functions without
+*  needing to have definitions for the real types. */
+
+typedef int   nvtx_CUdevice;
+typedef void* nvtx_CUcontext;
+typedef void* nvtx_CUstream;
+typedef void* nvtx_CUevent;
+
+typedef void* nvtx_cudaStream_t;
+typedef void* nvtx_cudaEvent_t;
+
+typedef void* nvtx_cl_platform_id;
+typedef void* nvtx_cl_device_id;
+typedef void* nvtx_cl_context;
+typedef void* nvtx_cl_command_queue;
+typedef void* nvtx_cl_mem;
+typedef void* nvtx_cl_program;
+typedef void* nvtx_cl_kernel;
+typedef void* nvtx_cl_event;
+typedef void* nvtx_cl_sampler;
+
+typedef struct nvtxSyncUser* nvtxSyncUser_t;
+struct nvtxSyncUserAttributes_v0;
+typedef struct nvtxSyncUserAttributes_v0 nvtxSyncUserAttributes_t;
+
+/* --------- Types for function pointers (with fake API types) ---------- */
+
+typedef void (NVTX_API * nvtxMarkEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib);
+typedef void (NVTX_API * nvtxMarkA_impl_fntype)(const char* message);
+typedef void (NVTX_API * nvtxMarkW_impl_fntype)(const wchar_t* message);
+typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib);
+typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartA_impl_fntype)(const char* message);
+typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartW_impl_fntype)(const wchar_t* message);
+typedef void (NVTX_API * nvtxRangeEnd_impl_fntype)(nvtxRangeId_t id);
+typedef int (NVTX_API * nvtxRangePushEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib);
+typedef int (NVTX_API * nvtxRangePushA_impl_fntype)(const char* message);
+typedef int (NVTX_API * nvtxRangePushW_impl_fntype)(const wchar_t* message);
+typedef int (NVTX_API * nvtxRangePop_impl_fntype)(void);
+typedef void (NVTX_API * nvtxNameCategoryA_impl_fntype)(uint32_t category, const char* name);
+typedef void (NVTX_API * nvtxNameCategoryW_impl_fntype)(uint32_t category, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameOsThreadA_impl_fntype)(uint32_t threadId, const char* name);
+typedef void (NVTX_API * nvtxNameOsThreadW_impl_fntype)(uint32_t threadId, const wchar_t* name);
+
+/* Real impl types are defined in nvtxImplCuda_v3.h, where CUDA headers are included */
+typedef void (NVTX_API * nvtxNameCuDeviceA_fakeimpl_fntype)(nvtx_CUdevice device, const char* name);
+typedef void (NVTX_API * nvtxNameCuDeviceW_fakeimpl_fntype)(nvtx_CUdevice device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuContextA_fakeimpl_fntype)(nvtx_CUcontext context, const char* name);
+typedef void (NVTX_API * nvtxNameCuContextW_fakeimpl_fntype)(nvtx_CUcontext context, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuStreamA_fakeimpl_fntype)(nvtx_CUstream stream, const char* name);
+typedef void (NVTX_API * nvtxNameCuStreamW_fakeimpl_fntype)(nvtx_CUstream stream, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCuEventA_fakeimpl_fntype)(nvtx_CUevent event, const char* name);
+typedef void (NVTX_API * nvtxNameCuEventW_fakeimpl_fntype)(nvtx_CUevent event, const wchar_t* name);
+
+/* Real impl types are defined in nvtxImplOpenCL_v3.h, where OPENCL headers are included */
+typedef void (NVTX_API * nvtxNameClDeviceA_fakeimpl_fntype)(nvtx_cl_device_id device, const char* name);
+typedef void (NVTX_API * nvtxNameClDeviceW_fakeimpl_fntype)(nvtx_cl_device_id device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClContextA_fakeimpl_fntype)(nvtx_cl_context context, const char* name);
+typedef void (NVTX_API * nvtxNameClContextW_fakeimpl_fntype)(nvtx_cl_context context, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClCommandQueueA_fakeimpl_fntype)(nvtx_cl_command_queue command_queue, const char* name);
+typedef void (NVTX_API * nvtxNameClCommandQueueW_fakeimpl_fntype)(nvtx_cl_command_queue command_queue, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClMemObjectA_fakeimpl_fntype)(nvtx_cl_mem memobj, const char* name);
+typedef void (NVTX_API * nvtxNameClMemObjectW_fakeimpl_fntype)(nvtx_cl_mem memobj, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClSamplerA_fakeimpl_fntype)(nvtx_cl_sampler sampler, const char* name);
+typedef void (NVTX_API * nvtxNameClSamplerW_fakeimpl_fntype)(nvtx_cl_sampler sampler, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClProgramA_fakeimpl_fntype)(nvtx_cl_program program, const char* name);
+typedef void (NVTX_API * nvtxNameClProgramW_fakeimpl_fntype)(nvtx_cl_program program, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameClEventA_fakeimpl_fntype)(nvtx_cl_event evnt, const char* name);
+typedef void (NVTX_API * nvtxNameClEventW_fakeimpl_fntype)(nvtx_cl_event evnt, const wchar_t* name);
+
+/* Real impl types are defined in nvtxImplCudaRt_v3.h, where CUDART headers are included */
+typedef void (NVTX_API * nvtxNameCudaDeviceA_impl_fntype)(int device, const char* name);
+typedef void (NVTX_API * nvtxNameCudaDeviceW_impl_fntype)(int device, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCudaStreamA_fakeimpl_fntype)(nvtx_cudaStream_t stream, const char* name);
+typedef void (NVTX_API * nvtxNameCudaStreamW_fakeimpl_fntype)(nvtx_cudaStream_t stream, const wchar_t* name);
+typedef void (NVTX_API * nvtxNameCudaEventA_fakeimpl_fntype)(nvtx_cudaEvent_t event, const char* name);
+typedef void (NVTX_API * nvtxNameCudaEventW_fakeimpl_fntype)(nvtx_cudaEvent_t event, const wchar_t* name);
+
+typedef void (NVTX_API * nvtxDomainMarkEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+typedef nvtxRangeId_t (NVTX_API * nvtxDomainRangeStartEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+typedef void (NVTX_API * nvtxDomainRangeEnd_impl_fntype)(nvtxDomainHandle_t domain, nvtxRangeId_t id);
+typedef int (NVTX_API * nvtxDomainRangePushEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib);
+typedef int (NVTX_API * nvtxDomainRangePop_impl_fntype)(nvtxDomainHandle_t domain);
+typedef nvtxResourceHandle_t (NVTX_API * nvtxDomainResourceCreate_impl_fntype)(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs);
+typedef void (NVTX_API * nvtxDomainResourceDestroy_impl_fntype)(nvtxResourceHandle_t resource);
+typedef void (NVTX_API * nvtxDomainNameCategoryA_impl_fntype)(nvtxDomainHandle_t domain, uint32_t category, const char* name);
+typedef void (NVTX_API * nvtxDomainNameCategoryW_impl_fntype)(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name);
+typedef nvtxStringHandle_t (NVTX_API * nvtxDomainRegisterStringA_impl_fntype)(nvtxDomainHandle_t domain, const char* string);
+typedef nvtxStringHandle_t (NVTX_API * nvtxDomainRegisterStringW_impl_fntype)(nvtxDomainHandle_t domain, const wchar_t* string);
+typedef nvtxDomainHandle_t (NVTX_API * nvtxDomainCreateA_impl_fntype)(const char* message);
+typedef nvtxDomainHandle_t (NVTX_API * nvtxDomainCreateW_impl_fntype)(const wchar_t* message);
+typedef void (NVTX_API * nvtxDomainDestroy_impl_fntype)(nvtxDomainHandle_t domain);
+typedef void (NVTX_API * nvtxInitialize_impl_fntype)(const void* reserved);
+
+typedef nvtxSyncUser_t (NVTX_API * nvtxDomainSyncUserCreate_impl_fntype)(nvtxDomainHandle_t domain, const nvtxSyncUserAttributes_t* attribs);
+typedef void (NVTX_API * nvtxDomainSyncUserDestroy_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireStart_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireFailed_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserAcquireSuccess_impl_fntype)(nvtxSyncUser_t handle);
+typedef void (NVTX_API * nvtxDomainSyncUserReleasing_impl_fntype)(nvtxSyncUser_t handle);
+
+/* ---------------- Types for callback subscription --------------------- */
+
+typedef const void *(NVTX_API * NvtxGetExportTableFunc_t)(uint32_t exportTableId);
+typedef int (NVTX_API * NvtxInitializeInjectionNvtxFunc_t)(NvtxGetExportTableFunc_t exportTable);
+
+typedef enum NvtxCallbackModule
+{
+    NVTX_CB_MODULE_INVALID                 = 0,
+    NVTX_CB_MODULE_CORE                    = 1,
+    NVTX_CB_MODULE_CUDA                    = 2,
+    NVTX_CB_MODULE_OPENCL                  = 3,
+    NVTX_CB_MODULE_CUDART                  = 4,
+    NVTX_CB_MODULE_CORE2                   = 5,
+    NVTX_CB_MODULE_SYNC                    = 6,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CB_MODULE_SIZE,
+    NVTX_CB_MODULE_FORCE_INT               = 0x7fffffff
+} NvtxCallbackModule;
+
+typedef enum NvtxCallbackIdCore
+{
+    NVTX_CBID_CORE_INVALID                 =  0,
+    NVTX_CBID_CORE_MarkEx                  =  1,
+    NVTX_CBID_CORE_MarkA                   =  2,
+    NVTX_CBID_CORE_MarkW                   =  3,
+    NVTX_CBID_CORE_RangeStartEx            =  4,
+    NVTX_CBID_CORE_RangeStartA             =  5,
+    NVTX_CBID_CORE_RangeStartW             =  6,
+    NVTX_CBID_CORE_RangeEnd                =  7,
+    NVTX_CBID_CORE_RangePushEx             =  8,
+    NVTX_CBID_CORE_RangePushA              =  9,
+    NVTX_CBID_CORE_RangePushW              = 10,
+    NVTX_CBID_CORE_RangePop                = 11,
+    NVTX_CBID_CORE_NameCategoryA           = 12,
+    NVTX_CBID_CORE_NameCategoryW           = 13,
+    NVTX_CBID_CORE_NameOsThreadA           = 14,
+    NVTX_CBID_CORE_NameOsThreadW           = 15,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_CORE_SIZE,
+    NVTX_CBID_CORE_FORCE_INT = 0x7fffffff
+} NvtxCallbackIdCore;
+
+typedef enum NvtxCallbackIdCore2
+{
+    NVTX_CBID_CORE2_INVALID                 = 0,
+    NVTX_CBID_CORE2_DomainMarkEx            = 1,
+    NVTX_CBID_CORE2_DomainRangeStartEx      = 2,
+    NVTX_CBID_CORE2_DomainRangeEnd          = 3,
+    NVTX_CBID_CORE2_DomainRangePushEx       = 4,
+    NVTX_CBID_CORE2_DomainRangePop          = 5,
+    NVTX_CBID_CORE2_DomainResourceCreate    = 6,
+    NVTX_CBID_CORE2_DomainResourceDestroy   = 7,
+    NVTX_CBID_CORE2_DomainNameCategoryA     = 8,
+    NVTX_CBID_CORE2_DomainNameCategoryW     = 9,
+    NVTX_CBID_CORE2_DomainRegisterStringA   = 10,
+    NVTX_CBID_CORE2_DomainRegisterStringW   = 11,
+    NVTX_CBID_CORE2_DomainCreateA           = 12,
+    NVTX_CBID_CORE2_DomainCreateW           = 13,
+    NVTX_CBID_CORE2_DomainDestroy           = 14,
+    NVTX_CBID_CORE2_Initialize              = 15,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_CORE2_SIZE,
+    NVTX_CBID_CORE2_FORCE_INT               = 0x7fffffff
+} NvtxCallbackIdCore2;
+
+typedef enum NvtxCallbackIdCuda
+{
+    NVTX_CBID_CUDA_INVALID                 =  0,
+    NVTX_CBID_CUDA_NameCuDeviceA           =  1,
+    NVTX_CBID_CUDA_NameCuDeviceW           =  2,
+    NVTX_CBID_CUDA_NameCuContextA          =  3,
+    NVTX_CBID_CUDA_NameCuContextW          =  4,
+    NVTX_CBID_CUDA_NameCuStreamA           =  5,
+    NVTX_CBID_CUDA_NameCuStreamW           =  6,
+    NVTX_CBID_CUDA_NameCuEventA            =  7,
+    NVTX_CBID_CUDA_NameCuEventW            =  8,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_CUDA_SIZE,
+    NVTX_CBID_CUDA_FORCE_INT               = 0x7fffffff
+} NvtxCallbackIdCuda;
+
+typedef enum NvtxCallbackIdCudaRt
+{
+    NVTX_CBID_CUDART_INVALID               =  0,
+    NVTX_CBID_CUDART_NameCudaDeviceA       =  1,
+    NVTX_CBID_CUDART_NameCudaDeviceW       =  2,
+    NVTX_CBID_CUDART_NameCudaStreamA       =  3,
+    NVTX_CBID_CUDART_NameCudaStreamW       =  4,
+    NVTX_CBID_CUDART_NameCudaEventA        =  5,
+    NVTX_CBID_CUDART_NameCudaEventW        =  6,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_CUDART_SIZE,
+    NVTX_CBID_CUDART_FORCE_INT             = 0x7fffffff
+} NvtxCallbackIdCudaRt;
+
+typedef enum NvtxCallbackIdOpenCL
+{
+    NVTX_CBID_OPENCL_INVALID               =  0,
+    NVTX_CBID_OPENCL_NameClDeviceA         =  1,
+    NVTX_CBID_OPENCL_NameClDeviceW         =  2,
+    NVTX_CBID_OPENCL_NameClContextA        =  3,
+    NVTX_CBID_OPENCL_NameClContextW        =  4,
+    NVTX_CBID_OPENCL_NameClCommandQueueA   =  5,
+    NVTX_CBID_OPENCL_NameClCommandQueueW   =  6,
+    NVTX_CBID_OPENCL_NameClMemObjectA      =  7,
+    NVTX_CBID_OPENCL_NameClMemObjectW      =  8,
+    NVTX_CBID_OPENCL_NameClSamplerA        =  9,
+    NVTX_CBID_OPENCL_NameClSamplerW        = 10,
+    NVTX_CBID_OPENCL_NameClProgramA        = 11,
+    NVTX_CBID_OPENCL_NameClProgramW        = 12,
+    NVTX_CBID_OPENCL_NameClEventA          = 13,
+    NVTX_CBID_OPENCL_NameClEventW          = 14,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_OPENCL_SIZE,
+    NVTX_CBID_OPENCL_FORCE_INT             = 0x7fffffff
+} NvtxCallbackIdOpenCL;
+
+typedef enum NvtxCallbackIdSync
+{
+    NVTX_CBID_SYNC_INVALID                      = 0,
+    NVTX_CBID_SYNC_DomainSyncUserCreate         = 1,
+    NVTX_CBID_SYNC_DomainSyncUserDestroy        = 2,
+    NVTX_CBID_SYNC_DomainSyncUserAcquireStart   = 3,
+    NVTX_CBID_SYNC_DomainSyncUserAcquireFailed  = 4,
+    NVTX_CBID_SYNC_DomainSyncUserAcquireSuccess = 5,
+    NVTX_CBID_SYNC_DomainSyncUserReleasing      = 6,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_CBID_SYNC_SIZE,
+    NVTX_CBID_SYNC_FORCE_INT                    = 0x7fffffff
+} NvtxCallbackIdSync;
+
+/* IDs for NVTX Export Tables */
+typedef enum NvtxExportTableID
+{
+    NVTX_ETID_INVALID                      = 0,
+    NVTX_ETID_CALLBACKS                    = 1,
+    NVTX_ETID_RESERVED0                    = 2,
+    NVTX_ETID_VERSIONINFO                  = 3,
+    /* --- New constants must only be added directly above this line --- */
+    NVTX_ETID_SIZE,
+    NVTX_ETID_FORCE_INT                    = 0x7fffffff
+} NvtxExportTableID;
+
+typedef void (* NvtxFunctionPointer)(void); /* generic uncallable function pointer, must be casted to appropriate function type */
+typedef NvtxFunctionPointer** NvtxFunctionTable; /* double pointer because array(1) of pointers(2) to function pointers */
+
+typedef struct NvtxExportTableCallbacks
+{
+    size_t struct_size;
+
+    /* returns an array of pointer to function pointers*/
+    int (NVTX_API *GetModuleFunctionTable)(
+        NvtxCallbackModule module,
+        NvtxFunctionTable* out_table,
+        unsigned int* out_size);
+} NvtxExportTableCallbacks;
+
+typedef struct NvtxExportTableVersionInfo
+{
+    /* sizeof(NvtxExportTableVersionInfo) */
+    size_t struct_size;
+
+    /* The API version comes from the NVTX library linked to the app.  The
+    * injection library is can use this info to make some assumptions */
+    uint32_t version;
+
+    /* Reserved for alignment, do not use */
+    uint32_t reserved0;
+
+    /* This must be set by tools when attaching to provide applications
+    *  the ability to, in emergency situations, detect problematic tools
+    *  versions and modify the NVTX source to prevent attaching anything
+    *  that causes trouble in the app.  Currently, this value is ignored. */
+    void (NVTX_API *SetInjectionNvtxVersion)(
+        uint32_t version);
+} NvtxExportTableVersionInfo;
+
+
+
+
+
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/addressof.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/addressof.h
new file mode 100644
index 0000000000000000000000000000000000000000..d21df0c76a5ecf90a19a0dc655854ea8228f7ce5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/addressof.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+#  include <thrust/detail/memory_wrapper.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
+ */
+template <typename T>
+__host__ __device__
+T* addressof(T& arg) 
+{
+  return reinterpret_cast<T*>(
+    &const_cast<char&>(reinterpret_cast<const volatile char&>(arg))
+  );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/adjacent_difference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/adjacent_difference.h
new file mode 100644
index 0000000000000000000000000000000000000000..e8385c240dd9a3466df10a73ba0adb532266d42c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/adjacent_difference.h
@@ -0,0 +1,244 @@
+/*
+ *  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 adjacent_difference.h
+ *  \brief Compute difference between consecutive elements of a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations Transformations
+ *  \{
+ */
+
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>\*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, the difference of <tt>\*i</tt> and <tt>*(i - 1)</tt>
+ *  is assigned to <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses <tt>operator-</tt> to calculate
+ *  differences.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \c x and \c y are objects of \p InputIterator's \c value_type, then \c x - \c is defined,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types,
+ *          and the return type of <tt>x - y</tt> is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the difference between adjacent elements of a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin());
+ *
+ *  // d_result is now [1, 1, -1, 1, -1, 1, -1, 1]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator adjacent_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last, 
+                                   OutputIterator result);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, <tt>binary_op(\*i, \*(i - 1))</tt> is assigned to
+ *  <tt>\*(result + (i - first))</tt>.
+ *  
+ *  This version of \p adjacent_difference uses the binary function \p binary_op to
+ *  calculate differences.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_op The binary function used to compute differences.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam BinaryFunction's \c result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the sum between adjacent elements of a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(thrust::device, d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());
+ *
+ *  // d_result is now [1, 3, 3, 3, 3, 3, 3, 3]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__
+OutputIterator adjacent_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>\*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, the difference of <tt>\*i</tt> and <tt>*(i - 1)</tt>
+ *  is assigned to <tt>\*(result + (i - first))</tt>.
+ *
+ *  This version of \p adjacent_difference uses <tt>operator-</tt> to calculate
+ *  differences.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \c x and \c y are objects of \p InputIterator's \c value_type, then \c x - \c is defined,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types,
+ *          and the return type of <tt>x - y</tt> is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the difference between adjacent elements of a range.
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin());
+ *
+ *  // d_result is now [1, 1, -1, 1, -1, 1, -1, 1]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename InputIterator, typename OutputIterator>
+OutputIterator adjacent_difference(InputIterator first, InputIterator last, 
+                                   OutputIterator result);
+
+/*! \p adjacent_difference calculates the differences of adjacent elements in the
+ *  range <tt>[first, last)</tt>. That is, <tt>*first</tt> is assigned to
+ *  <tt>\*result</tt>, and, for each iterator \p i in the range
+ *  <tt>[first + 1, last)</tt>, <tt>binary_op(\*i, \*(i - 1))</tt> is assigned to
+ *  <tt>\*(result + (i - first))</tt>.
+ *  
+ *  This version of \p adjacent_difference uses the binary function \p binary_op to
+ *  calculate differences.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_op The binary function used to compute differences.
+ *  \return The iterator <tt>result + (last - first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam BinaryFunction's \c result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  \remark Note that \p result is permitted to be the same iterator as \p first. This is
+ *          useful for computing differences "in place".
+ *
+ *  The following code snippet demonstrates how to use \p adjacent_difference to compute
+ *  the sum between adjacent elements of a range.
+ *
+ *  \code
+ *  #include <thrust/adjacent_difference.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  int h_data[8] = {1, 2, 1, 2, 1, 2, 1, 2};
+ *  thrust::device_vector<int> d_data(h_data, h_data + 8);
+ *  thrust::device_vector<int> d_result(8);
+ *
+ *  thrust::adjacent_difference(d_data.begin(), d_data.end(), d_result.begin(), thrust::plus<int>());
+ *
+ *  // d_result is now [1, 3, 3, 3, 3, 3, 3, 3]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/adjacent_difference
+ *  \see inclusive_scan
+ */
+template <typename InputIterator, typename OutputIterator, typename BinaryFunction>
+OutputIterator adjacent_difference(InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op);
+
+/*! \}
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/adjacent_difference.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/advance.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/advance.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5162e2030027393c3033cfb0ac040124cc834de
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/advance.h
@@ -0,0 +1,140 @@
+/*
+ *  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 advance.h
+ *  \brief Advance an iterator by a given distance.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \p advance(i, n) increments the iterator \p i by the distance \p n.
+ *  If <tt>n > 0</tt> it is equivalent to executing <tt>++i</tt> \p n
+ *  times, and if <tt>n < 0</tt> it is equivalent to executing <tt>--i</tt>
+ *  \p n times. If <tt>n == 0</tt>, the call has no effect.
+ *
+ *  \param i The iterator to be advanced.
+ *  \param n The distance by which to advance the iterator.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Distance is an integral type that is convertible to \p InputIterator's distance type.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p advance to increment
+ *  an iterator a given number of times.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator iter = vec.begin();
+ *
+ *  thrust::advance(iter, 7);
+ *
+ *  // iter - vec.begin() == 7
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/advance
+ */
+template <typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n);
+
+/*! \p next(i, n) returns the \p n th successor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to advance.
+ *
+ *  \tparam InputIterator must meet the <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">InputIterator</a>.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p next.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.begin();
+ *
+ *  auto i1 = thrust::next(i0);
+ *
+ *  // i0 - vec.begin() == 0
+ *  // i1 - vec.begin() == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/next
+ */
+#if 0 // Doxygen only
+template <typename InputIterator, typename Distance>
+__host__ __device__
+InputIterator next(
+  InputIterator i
+, typename iterator_traits<InputIterator>::difference_type n = 1
+);
+#endif
+
+/*! \p prev(i, n) returns the \p n th predecessor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to descend.
+ *
+ *  \tparam BidirectionalIterator must meet the <a href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator">BidirectionalIterator</a>.
+ *
+ *  The following code snippet demonstrates how to use \p prev.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.end();
+ *
+ *  auto i1 = thrust::prev(i0);
+ *
+ *  // vec.end() - i0 == 0
+ *  // vec.end() - i1 == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/prev
+ */
+#if 0 // Doxygen only
+template <typename BidirectionalIterator, typename Distance>
+__host__ __device__
+BidirectionalIterator prev(
+  BidirectionalIterator i
+, typename iterator_traits<BidirectionalIterator>::difference_type n = 1
+);
+#endif
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/advance.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/allocate_unique.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/allocate_unique.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff10cb51cd19c74cf53c75ef281c7dd5fc1298a8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/allocate_unique.h
@@ -0,0 +1,443 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/detail/memory_algorithms.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+
+#include <utility>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// wg21.link/p0316r0
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace detail
+{
+
+template <typename Allocator, typename Pointer>
+void allocator_delete_impl(
+  Allocator const& alloc, Pointer p, std::false_type
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::destroy(alloc_T, thrust::raw_pointer_cast(p));
+    traits::deallocate(alloc_T, p, 1);
+  }
+}
+
+template <typename Allocator, typename Pointer>
+void allocator_delete_impl(
+  Allocator const& alloc, Pointer p, std::true_type
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::deallocate(alloc_T, p, 1);
+  }
+}
+
+} // namespace detail
+
+template <typename T, typename Allocator, bool Uninitialized = false>
+struct allocator_delete final
+{
+  using allocator_type
+    = typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type::template rebind<T>::other;
+  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
+
+  template <typename UAllocator>
+  allocator_delete(UAllocator&& other) noexcept
+    : alloc_(THRUST_FWD(other))
+  {}
+
+  template <typename U, typename UAllocator>
+  allocator_delete(
+      allocator_delete<U, UAllocator> const& other
+    ) noexcept
+    : alloc_(other.get_allocator())
+  {}
+  template <typename U, typename UAllocator>
+  allocator_delete(
+      allocator_delete<U, UAllocator>&& other
+    ) noexcept
+    : alloc_(std::move(other.get_allocator()))
+  {}
+
+  template <typename U, typename UAllocator>
+  allocator_delete& operator=(
+    allocator_delete<U, UAllocator> const& other
+  ) noexcept
+  {
+    alloc_ = other.get_allocator();
+    return *this;
+  }
+  template <typename U, typename UAllocator>
+  allocator_delete& operator=(
+    allocator_delete<U, UAllocator>&& other
+  ) noexcept
+  {
+    alloc_ = std::move(other.get_allocator());
+    return *this;
+  }
+
+  void operator()(pointer p)
+  {
+    std::integral_constant<bool, Uninitialized> ic;
+
+    detail::allocator_delete_impl(get_allocator(), p, ic);
+  }
+
+  allocator_type& get_allocator() noexcept { return alloc_; }
+  allocator_type const& get_allocator() const noexcept { return alloc_; }
+
+  void swap(allocator_delete& other) noexcept
+  {
+    using std::swap;
+    swap(alloc_, other.alloc_);
+  }
+
+private:
+  allocator_type alloc_;
+};
+
+template <typename T, typename Allocator>
+using uninitialized_allocator_delete = allocator_delete<T, Allocator, true>;
+
+namespace detail {
+
+template <typename Allocator, typename Pointer, typename Size>
+void array_allocator_delete_impl(
+  Allocator const& alloc, Pointer p, Size count, std::false_type
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    destroy_n(alloc_T, p, count);
+    traits::deallocate(alloc_T, p, count);
+  }
+}
+
+template <typename Allocator, typename Pointer, typename Size>
+void array_allocator_delete_impl(
+  Allocator const& alloc, Pointer p, Size count, std::true_type
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  if (nullptr != pointer_traits<Pointer>::get(p))
+  {
+    traits::deallocate(alloc_T, p, count);
+  }
+}
+
+} // namespace detail
+
+template <typename T, typename Allocator, bool Uninitialized = false>
+struct array_allocator_delete final
+{
+  using allocator_type
+    = typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type::template rebind<T>::other;
+  using pointer = typename detail::allocator_traits<allocator_type>::pointer;
+
+  template <typename UAllocator>
+  array_allocator_delete(UAllocator&& other, std::size_t n) noexcept
+    : alloc_(THRUST_FWD(other)), count_(n)
+  {}
+
+  template <typename U, typename UAllocator>
+  array_allocator_delete(
+      array_allocator_delete<U, UAllocator> const& other
+    ) noexcept
+    : alloc_(other.get_allocator()), count_(other.count_)
+  {}
+  template <typename U, typename UAllocator>
+  array_allocator_delete(
+      array_allocator_delete<U, UAllocator>&& other
+    ) noexcept
+    : alloc_(std::move(other.get_allocator())), count_(other.count_)
+  {}
+
+  template <typename U, typename UAllocator>
+  array_allocator_delete& operator=(
+    array_allocator_delete<U, UAllocator> const& other
+  ) noexcept
+  {
+    alloc_ = other.get_allocator();
+    count_ = other.count_;
+    return *this;
+  }
+  template <typename U, typename UAllocator>
+  array_allocator_delete& operator=(
+    array_allocator_delete<U, UAllocator>&& other
+  ) noexcept
+  {
+    alloc_ = std::move(other.get_allocator());
+    count_ = other.count_;
+    return *this;
+  }
+
+  void operator()(pointer p)
+  {
+    std::integral_constant<bool, Uninitialized> ic;
+
+    detail::array_allocator_delete_impl(get_allocator(), p, count_, ic);
+  }
+
+  allocator_type& get_allocator() noexcept { return alloc_; }
+  allocator_type const& get_allocator() const noexcept { return alloc_; }
+
+  void swap(array_allocator_delete& other) noexcept
+  {
+    using std::swap;
+    swap(alloc_, other.alloc_);
+    swap(count_, other.count_);
+  }
+
+private:
+  allocator_type alloc_;
+  std::size_t    count_;
+};
+  
+template <typename T, typename Allocator>
+using uninitialized_array_allocator_delete
+  = array_allocator_delete<T, Allocator, true>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename Pointer, typename Lambda>
+struct tagged_deleter : Lambda
+{
+  __host__ __device__
+  tagged_deleter(Lambda&& l) : Lambda(THRUST_FWD(l)) {}
+
+  using pointer = Pointer;
+};
+
+template <typename Pointer, typename Lambda>
+__host__ __device__
+tagged_deleter<Pointer, Lambda>
+make_tagged_deleter(Lambda&& l)
+{
+  return tagged_deleter<Pointer, Lambda>(THRUST_FWD(l));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename Allocator, typename... Args>
+__host__
+std::unique_ptr<
+  T,
+  allocator_delete<
+    T
+  , typename detail::allocator_traits<
+      typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type
+    >::template rebind_traits<T>::allocator_type
+  >
+>
+allocate_unique(
+  Allocator const& alloc, Args&&... args
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
+    [&alloc_T] (typename traits::pointer p) {
+      traits::deallocate(alloc_T, p, 1);
+    }
+  );
+  using hold_t = std::unique_ptr<T, decltype(hold_deleter)>;
+  auto hold = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
+
+  traits::construct(
+    alloc_T, thrust::raw_pointer_cast(hold.get()), THRUST_FWD(args)...
+  );
+  auto deleter = allocator_delete<T, typename traits::allocator_type>(alloc);
+  return std::unique_ptr<T, decltype(deleter)>
+    (hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator>
+__host__
+std::unique_ptr<
+  T,
+  uninitialized_allocator_delete<
+    T
+  , typename detail::allocator_traits<
+      typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type
+    >::template rebind_traits<T>::allocator_type
+  >
+>
+uninitialized_allocate_unique(
+  Allocator const& alloc
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
+    [&alloc_T] (typename traits::pointer p) {
+      traits::deallocate(alloc_T, p, 1);
+    }
+  );
+  using hold_t = std::unique_ptr<T, decltype(hold_deleter)>;
+  auto hold = hold_t(traits::allocate(alloc_T, 1), hold_deleter);
+
+  auto deleter = uninitialized_allocator_delete<
+    T, typename traits::allocator_type
+  >(alloc_T);
+  return std::unique_ptr<T, decltype(deleter)>
+    (hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator, typename Size, typename... Args>
+__host__
+std::unique_ptr<
+  T[],
+  array_allocator_delete<
+    T
+  , typename detail::allocator_traits<
+      typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type
+    >::template rebind_traits<T>::allocator_type
+  >
+>
+allocate_unique_n(
+  Allocator const& alloc, Size n, Args&&... args
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
+    [n, &alloc_T] (typename traits::pointer p) {
+      traits::deallocate(alloc_T, p, n);
+    }
+  );
+  using hold_t = std::unique_ptr<T[], decltype(hold_deleter)>;
+  auto hold = hold_t(traits::allocate(alloc_T, n), hold_deleter);
+
+  uninitialized_construct_n_with_allocator(
+    alloc_T, hold.get(), n, THRUST_FWD(args)...
+  );
+  auto deleter = array_allocator_delete<
+    T, typename traits::allocator_type
+  >(alloc_T, n);
+  return std::unique_ptr<T[], decltype(deleter)>
+    (hold.release(), std::move(deleter));
+}
+
+template <typename T, typename Allocator, typename Size>
+__host__
+std::unique_ptr<
+  T[],
+  uninitialized_array_allocator_delete<
+    T
+  , typename detail::allocator_traits<
+      typename std::remove_cv<
+        typename std::remove_reference<Allocator>::type
+      >::type
+    >::template rebind_traits<T>::allocator_type
+  >
+>
+uninitialized_allocate_unique_n(
+  Allocator const& alloc, Size n
+)
+{
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  auto hold_deleter = make_tagged_deleter<typename traits::pointer>(
+    [n, &alloc_T] (typename traits::pointer p) {
+      traits::deallocate(alloc_T, p, n);
+    }
+  );
+  using hold_t = std::unique_ptr<T[], decltype(hold_deleter)>;
+  auto hold = hold_t(traits::allocate(alloc_T, n), hold_deleter);
+
+  auto deleter = uninitialized_array_allocator_delete<
+    T, typename traits::allocator_type
+  >(alloc_T, n);
+  return std::unique_ptr<T[], decltype(deleter)>
+    (hold.release(), std::move(deleter));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8edc7411e59ae7caf14273be04526a49ad3e752
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/copy.h
@@ -0,0 +1,154 @@
+/*
+ *  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 Algorithms for asynchronously copying a range.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/system/detail/adl/async/copy.h>
+
+#include <thrust/event.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+/*! \cond
+ */
+
+namespace unimplemented
+{
+
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+__host__
+event<FromPolicy>
+async_copy(
+  thrust::execution_policy<FromPolicy>& from_exec
+, thrust::execution_policy<ToPolicy>&   to_exec
+, ForwardIt first, Sentinel last, OutputIt output
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace copy_detail
+{
+
+using thrust::async::unimplemented::async_copy;
+
+struct copy_fn final
+{
+  template <
+    typename FromPolicy, typename ToPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<FromPolicy> const& from_exec
+  , thrust::detail::execution_policy_base<ToPolicy> const&   to_exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_copy(
+      thrust::detail::derived_cast(thrust::detail::strip_const(from_exec))
+    , thrust::detail::derived_cast(thrust::detail::strip_const(to_exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  )
+  THRUST_RETURNS(
+    copy_fn::call(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+      // Synthesize a suitable new execution policy, because we don't want to
+      // try and extract twice from the one we were passed.
+    , typename remove_cvref_t<
+        decltype(thrust::detail::derived_cast(thrust::detail::strip_const(exec)))
+      >::tag_type{}
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename OutputIt>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last, OutputIt&& output)
+  THRUST_RETURNS(
+    copy_fn::call(
+      thrust::detail::select_system(
+        typename thrust::iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , thrust::detail::select_system(
+        typename thrust::iterator_system<remove_cvref_t<OutputIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace copy_detail
+
+THRUST_INLINE_CONSTANT copy_detail::copy_fn copy{};
+
+/*! \endcond
+ */
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d3b3a1890507cbb60b2c886f4b66e8a2b87d1bd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/for_each.h
@@ -0,0 +1,123 @@
+/*
+ *  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 Algorithms for asynchronously iterating over the elements of a range.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/system/detail/adl/async/for_each.h>
+
+#include <thrust/event.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+/*! \cond
+ */
+
+namespace unimplemented
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename UnaryFunction
+>
+__host__
+event<DerivedPolicy>
+async_for_each(
+  thrust::execution_policy<DerivedPolicy>&, ForwardIt, Sentinel, UnaryFunction
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace for_each_detail
+{
+
+using thrust::async::unimplemented::async_for_each;
+
+struct for_each_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename UnaryFunction
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , UnaryFunction&& f
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_for_each(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(f)
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename UnaryFunction>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last, UnaryFunction&& f)
+  THRUST_RETURNS(
+    for_each_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(f)
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace for_each_detail
+
+THRUST_INLINE_CONSTANT for_each_detail::for_each_fn for_each{};
+
+/*! \endcond
+ */
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f4fe3133e6f5622132b78c8cb907af94d930242
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/reduce.h
@@ -0,0 +1,446 @@
+/*
+ *  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 Algorithms for asynchronously reducing a range to a single value.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/type_traits/is_execution_policy.h>
+#include <thrust/system/detail/adl/async/reduce.h>
+
+#include <thrust/future.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+/*! \cond
+ */
+
+namespace unimplemented
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename T, typename BinaryOp
+>
+__host__
+future<DerivedPolicy, T>
+async_reduce(
+  thrust::execution_policy<DerivedPolicy>&, ForwardIt, Sentinel, T, BinaryOp
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace reduce_detail
+{
+
+using thrust::async::unimplemented::async_reduce;
+
+struct reduce_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename T, typename BinaryOp
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , T&& init
+  , BinaryOp&& op
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(init)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename T
+  >
+  __host__
+  static auto call4(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , T&& init
+  , thrust::true_type
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(init)
+    , thrust::plus<remove_cvref_t<T>>{}
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel
+  >
+  __host__
+  static auto
+  call3(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , thrust::true_type
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type{}
+    , thrust::plus<
+        remove_cvref_t<
+          typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+        >
+      >{}
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename T, typename BinaryOp>
+  __host__
+  static auto call4(ForwardIt&& first, Sentinel&& last,
+                    T&& init,
+                    BinaryOp&& op,
+                    thrust::false_type)
+  THRUST_RETURNS(
+    reduce_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(init)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename T>
+  __host__
+  static auto call3(ForwardIt&& first, Sentinel&& last,
+                    T&& init,
+                    thrust::false_type)
+  THRUST_RETURNS(
+    reduce_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(init)
+    , thrust::plus<remove_cvref_t<T>>{}
+    )
+  )
+
+  // MSVC WAR: MSVC gets angsty and eats all available RAM when we try to detect
+  // if T1 is an execution_policy by using SFINAE. Switching to a static
+  // dispatch pattern to prevent this.
+  template <typename T1, typename T2, typename T3>
+  __host__
+  static auto call(T1&& t1, T2&& t2, T3&& t3)
+  THRUST_RETURNS(
+    reduce_fn::call3(THRUST_FWD(t1), THRUST_FWD(t2), THRUST_FWD(t3),
+                     thrust::is_execution_policy<thrust::remove_cvref_t<T1>>{})
+  )
+
+  template <typename T1, typename T2, typename T3, typename T4>
+  __host__
+  static auto call(T1&& t1, T2&& t2, T3&& t3, T4&& t4)
+  THRUST_RETURNS(
+    reduce_fn::call4(THRUST_FWD(t1), THRUST_FWD(t2), THRUST_FWD(t3), THRUST_FWD(t4),
+                     thrust::is_execution_policy<thrust::remove_cvref_t<T1>>{})
+  )
+
+  template <typename ForwardIt, typename Sentinel>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last)
+  THRUST_RETURNS(
+    reduce_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type{}
+    , thrust::plus<
+        remove_cvref_t<
+          typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+        >
+      >{}
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace reduce_detail
+
+THRUST_INLINE_CONSTANT reduce_detail::reduce_fn reduce{};
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace unimplemented
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename T, typename BinaryOp
+>
+__host__
+event<DerivedPolicy>
+async_reduce_into(
+  thrust::execution_policy<DerivedPolicy>&
+, ForwardIt, Sentinel, OutputIt, T, BinaryOp
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace reduce_into_detail
+{
+
+using thrust::async::unimplemented::async_reduce_into;
+
+struct reduce_into_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename T, typename BinaryOp
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , T&& init
+  , BinaryOp&& op
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce_into(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(init)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename T
+  >
+  __host__
+  static auto call5(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , T&& init
+  , thrust::true_type
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce_into(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(init)
+    , thrust::plus<remove_cvref_t<T>>{}
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  >
+  __host__
+  static auto
+  call4(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , thrust::true_type
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_reduce_into(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type{}
+    , thrust::plus<
+        remove_cvref_t<
+          typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+        >
+      >{}
+    )
+  )
+
+  template <
+    typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename T, typename BinaryOp
+  >
+  __host__
+  static auto call5(
+    ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , T&& init
+  , BinaryOp&& op
+  , thrust::false_type
+  )
+  THRUST_RETURNS(
+    reduce_into_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      , typename iterator_system<remove_cvref_t<OutputIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(init)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <
+    typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename T
+  >
+  __host__
+  static auto call4(
+    ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , T&& init
+  , thrust::false_type
+  )
+  THRUST_RETURNS(
+    reduce_into_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      , typename iterator_system<remove_cvref_t<OutputIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(init)
+    , thrust::plus<remove_cvref_t<T>>{}
+    )
+  )
+
+  template <
+    typename ForwardIt, typename Sentinel, typename OutputIt
+  >
+  __host__
+  static auto call(
+    ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  )
+  THRUST_RETURNS(
+    reduce_into_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      , typename iterator_system<remove_cvref_t<OutputIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type{}
+    , thrust::plus<
+        remove_cvref_t<
+          typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+        >
+      >{}
+    )
+  )
+
+  // MSVC WAR: MSVC gets angsty and eats all available RAM when we try to detect
+  // if T1 is an execution_policy by using SFINAE. Switching to a static
+  // dispatch pattern to prevent this.
+  template <typename T1, typename T2, typename T3, typename T4>
+  __host__
+  static auto call(T1&& t1, T2&& t2, T3&& t3, T4&& t4)
+  THRUST_RETURNS(
+    reduce_into_fn::call4(
+      THRUST_FWD(t1), THRUST_FWD(t2), THRUST_FWD(t3), THRUST_FWD(t4),
+      thrust::is_execution_policy<thrust::remove_cvref_t<T1>>{})
+  )
+
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  __host__
+  static auto call(T1&& t1, T2&& t2, T3&& t3, T4&& t4, T5&& t5)
+  THRUST_RETURNS(
+    reduce_into_fn::call5(
+      THRUST_FWD(t1), THRUST_FWD(t2), THRUST_FWD(t3), THRUST_FWD(t4),
+      THRUST_FWD(t5), thrust::is_execution_policy<thrust::remove_cvref_t<T1>>{})
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace reduce_into_detail
+
+THRUST_INLINE_CONSTANT reduce_into_detail::reduce_into_fn reduce_into{};
+
+/*! \endcond
+ */
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..1bcf812578076a0613a6800654653ae84526dcee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/scan.h
@@ -0,0 +1,344 @@
+/*
+ *  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.
+ */
+
+/*! \file async/scan.h
+ *  \brief Functions for asynchronously computing prefix scans.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/detail/static_assert.h>
+
+#include <thrust/system/detail/adl/async/scan.h>
+
+#include <thrust/type_traits/is_execution_policy.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <thrust/future.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+// Fallback implementations used when no overloads are found via ADL:
+namespace unimplemented
+{
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename BinaryOp>
+event<DerivedPolicy>
+async_inclusive_scan(thrust::execution_policy<DerivedPolicy>&,
+                     ForwardIt,
+                     Sentinel,
+                     OutputIt,
+                     BinaryOp)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value),
+    "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename InitialValueType,
+          typename BinaryOp>
+event<DerivedPolicy>
+async_exclusive_scan(thrust::execution_policy<DerivedPolicy>&,
+                     ForwardIt,
+                     Sentinel,
+                     OutputIt,
+                     InitialValueType,
+                     BinaryOp)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value),
+    "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace inclusive_scan_detail
+{
+
+// Include fallback implementation for ADL failures
+using thrust::async::unimplemented::async_inclusive_scan;
+
+// Implementation of the thrust::async::inclusive_scan CPO.
+struct inclusive_scan_fn final
+{
+  template <typename DerivedPolicy,
+            typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename BinaryOp>
+  auto
+  operator()(thrust::detail::execution_policy_base<DerivedPolicy> const& exec,
+             ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out,
+             BinaryOp&& op) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_inclusive_scan(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(op)
+    )
+  )
+
+  template <typename DerivedPolicy,
+            typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt>
+  auto
+  operator()(thrust::detail::execution_policy_base<DerivedPolicy> const& exec,
+             ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_inclusive_scan(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      thrust::plus<>{}
+    )
+  )
+
+  template <typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename BinaryOp,
+            typename = std::enable_if_t<!is_execution_policy_v<remove_cvref_t<ForwardIt>>>>
+  auto operator()(ForwardIt&& first,
+                  Sentinel&& last,
+                  OutputIt&& out,
+                  BinaryOp&& op) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_inclusive_scan(
+      thrust::detail::select_system(
+        iterator_system_t<remove_cvref_t<ForwardIt>>{},
+        iterator_system_t<remove_cvref_t<OutputIt>>{}
+      ),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(op)
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename OutputIt>
+  auto operator()(ForwardIt&& first, Sentinel&& last, OutputIt&& out) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_inclusive_scan(
+      thrust::detail::select_system(
+        iterator_system_t<remove_cvref_t<ForwardIt>>{},
+        iterator_system_t<remove_cvref_t<OutputIt>>{}
+      ),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      thrust::plus<>{}
+    )
+  )
+};
+
+} // namespace inclusive_scan_detail
+
+THRUST_INLINE_CONSTANT inclusive_scan_detail::inclusive_scan_fn inclusive_scan{};
+
+namespace exclusive_scan_detail
+{
+
+// Include fallback implementation for ADL failures
+using thrust::async::unimplemented::async_exclusive_scan;
+
+// Implementation of the thrust::async::exclusive_scan CPO.
+struct exclusive_scan_fn final
+{
+  template <typename DerivedPolicy,
+            typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename InitialValueType,
+            typename BinaryOp>
+  auto
+  operator()(thrust::detail::execution_policy_base<DerivedPolicy> const& exec,
+             ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out,
+             InitialValueType&& init,
+             BinaryOp&& op) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(init),
+      THRUST_FWD(op)
+    )
+  )
+
+  template <typename DerivedPolicy,
+            typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename InitialValueType>
+  auto
+  operator()(thrust::detail::execution_policy_base<DerivedPolicy> const& exec,
+             ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out,
+             InitialValueType&& init) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(init),
+      thrust::plus<>{}
+    )
+  )
+
+  template <typename DerivedPolicy,
+            typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt>
+  auto
+  operator()(thrust::detail::execution_policy_base<DerivedPolicy> const& exec,
+             ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      iterator_value_t<remove_cvref_t<ForwardIt>>{},
+      thrust::plus<>{}
+    )
+  )
+
+  template <typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename InitialValueType,
+            typename BinaryOp,
+            typename = std::enable_if_t<!is_execution_policy_v<remove_cvref_t<ForwardIt>>>>
+  auto
+  operator()(ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out,
+             InitialValueType&& init,
+             BinaryOp&& op) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::select_system(
+        iterator_system_t<remove_cvref_t<ForwardIt>>{},
+        iterator_system_t<remove_cvref_t<OutputIt>>{}
+      ),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(init),
+      THRUST_FWD(op)
+    )
+  )
+
+  template <typename ForwardIt,
+            typename Sentinel,
+            typename OutputIt,
+            typename InitialValueType,
+            typename = std::enable_if_t<!is_execution_policy_v<remove_cvref_t<ForwardIt>>>>
+  auto
+  operator()(ForwardIt&& first,
+             Sentinel&& last,
+             OutputIt&& out,
+             InitialValueType&& init) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::select_system(
+        iterator_system_t<remove_cvref_t<ForwardIt>>{},
+        iterator_system_t<remove_cvref_t<OutputIt>>{}
+      ),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      THRUST_FWD(init),
+      thrust::plus<>{}
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename OutputIt>
+  auto operator()(ForwardIt&& first,
+                  Sentinel&& last,
+                  OutputIt&& out) const
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_exclusive_scan(
+      thrust::detail::select_system(
+        iterator_system_t<remove_cvref_t<ForwardIt>>{},
+        iterator_system_t<remove_cvref_t<OutputIt>>{}
+      ),
+      THRUST_FWD(first),
+      THRUST_FWD(last),
+      THRUST_FWD(out),
+      iterator_value_t<remove_cvref_t<ForwardIt>>{},
+      thrust::plus<>{}
+    )
+  )
+};
+
+} // namespace exclusive_scan_detail
+
+THRUST_INLINE_CONSTANT exclusive_scan_detail::exclusive_scan_fn exclusive_scan{};
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..8881793970bf84495a046a6e5e07be8cf3fa5da4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/sort.h
@@ -0,0 +1,280 @@
+/*
+ *  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 Algorithms for asynchronously sorting a range.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/type_traits/is_execution_policy.h>
+#include <thrust/system/detail/adl/async/sort.h>
+
+#include <thrust/event.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+/*! \cond
+ */
+
+namespace unimplemented
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+>
+__host__
+event<DerivedPolicy>
+async_stable_sort(
+  thrust::execution_policy<DerivedPolicy>&
+, ForwardIt, Sentinel, StrictWeakOrdering
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace stable_sort_detail
+{
+
+using thrust::async::unimplemented::async_stable_sort;
+
+struct stable_sort_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , StrictWeakOrdering&& comp
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_stable_sort(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(comp)
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_stable_sort(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , thrust::less<
+        typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+      >{}
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename StrictWeakOrdering>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last, StrictWeakOrdering&& comp)
+  THRUST_RETURNS(
+    stable_sort_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(comp)
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last)
+  THRUST_RETURNS(
+    stable_sort_fn::call(
+      THRUST_FWD(first), THRUST_FWD(last)
+    , thrust::less<
+        typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+      >{}
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace stable_sort_detail
+
+THRUST_INLINE_CONSTANT stable_sort_detail::stable_sort_fn stable_sort{};
+
+namespace fallback
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+>
+__host__
+event<DerivedPolicy>
+async_sort(
+  thrust::execution_policy<DerivedPolicy>& exec
+, ForwardIt&& first, Sentinel&& last, StrictWeakOrdering&& comp
+)
+{
+  return async_stable_sort(
+    thrust::detail::derived_cast(exec)
+  , THRUST_FWD(first), THRUST_FWD(last), THRUST_FWD(comp)
+  );
+}
+
+} // namespace fallback
+
+namespace sort_detail
+{
+
+using thrust::async::fallback::async_sort;
+
+struct sort_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+  >
+  __host__
+  static auto call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , StrictWeakOrdering&& comp
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_sort(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(comp)
+    )
+  )
+
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel
+  >
+  __host__
+  static auto call3(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , thrust::true_type
+  )
+  THRUST_RETURNS(
+    sort_fn::call(
+      exec
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , thrust::less<
+        typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+      >{}
+    )
+  )
+
+  template <typename ForwardIt, typename Sentinel, typename StrictWeakOrdering>
+  __host__
+  static auto call3(ForwardIt&& first, Sentinel&& last,
+                    StrictWeakOrdering&& comp,
+                    thrust::false_type)
+  THRUST_RETURNS(
+    sort_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(comp)
+    )
+  )
+
+  // MSVC WAR: MSVC gets angsty and eats all available RAM when we try to detect
+  // if T1 is an execution_policy by using SFINAE. Switching to a static
+  // dispatch pattern to prevent this.
+  template <typename T1, typename T2, typename T3>
+  __host__
+  static auto call(T1&& t1, T2&& t2, T3&& t3)
+  THRUST_RETURNS(
+    sort_fn::call3(THRUST_FWD(t1), THRUST_FWD(t2), THRUST_FWD(t3),
+                   thrust::is_execution_policy<thrust::remove_cvref_t<T1>>{})
+  )
+
+  template <typename ForwardIt, typename Sentinel>
+  __host__
+  static auto call(ForwardIt&& first, Sentinel&& last)
+  THRUST_RETURNS(
+    sort_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , thrust::less<
+        typename iterator_traits<remove_cvref_t<ForwardIt>>::value_type
+      >{}
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace sort_detail
+
+THRUST_INLINE_CONSTANT sort_detail::sort_fn sort{};
+
+/*! \endcond
+ */
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..de72549bf01be62a2f6e267d43882dbf8121d63e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/async/transform.h
@@ -0,0 +1,138 @@
+/*
+ *  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 Algorithms for asynchronously transforming a range.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/select_system.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/system/detail/adl/async/transform.h>
+
+#include <thrust/event.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace async
+{
+
+/*! \cond
+ */
+
+namespace unimplemented
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename UnaryOperation
+>
+__host__
+event<DerivedPolicy>
+async_transform(
+  thrust::execution_policy<DerivedPolicy>& exec
+, ForwardIt first, Sentinel last, OutputIt output, UnaryOperation op
+)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<ForwardIt, false>::value)
+  , "this algorithm is not implemented for the specified system"
+  );
+  return {};
+}
+
+} // namespace unimplemented
+
+namespace transform_detail
+{
+
+using thrust::async::unimplemented::async_transform;
+
+struct transform_fn final
+{
+  template <
+    typename DerivedPolicy
+  , typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename UnaryOperation
+  >
+  __host__
+  static auto
+  call(
+    thrust::detail::execution_policy_base<DerivedPolicy> const& exec
+  , ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , UnaryOperation&& op
+  )
+  // ADL dispatch.
+  THRUST_RETURNS(
+    async_transform(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec))
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <
+    typename ForwardIt, typename Sentinel, typename OutputIt
+  , typename UnaryOperation
+  >
+  __host__
+  static auto call(
+    ForwardIt&& first, Sentinel&& last
+  , OutputIt&& output
+  , UnaryOperation&& op
+  )
+  THRUST_RETURNS(
+    transform_fn::call(
+      thrust::detail::select_system(
+        typename iterator_system<remove_cvref_t<ForwardIt>>::type{}
+      , typename iterator_system<remove_cvref_t<OutputIt>>::type{}
+      )
+    , THRUST_FWD(first), THRUST_FWD(last)
+    , THRUST_FWD(output)
+    , THRUST_FWD(op)
+    )
+  )
+
+  template <typename... Args>
+  THRUST_NODISCARD __host__
+  auto operator()(Args&&... args) const
+  THRUST_RETURNS(
+    call(THRUST_FWD(args)...)
+  )
+};
+
+} // namespace tranform_detail
+
+THRUST_INLINE_CONSTANT transform_detail::transform_fn transform{};
+
+/*! \endcond
+ */
+
+} // namespace async
+
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/binary_search.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/binary_search.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a4746e0b165a7da2f86e04e843ee43a2086e4cc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/binary_search.h
@@ -0,0 +1,1899 @@
+/*
+ *  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 binary_search.h
+ *  \brief Search for values in sorted ranges.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+
+/*! \addtogroup searching
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \addtogroup binary_search Binary Search
+ *  \ingroup searching
+ *  \{
+ */
+
+
+//////////////////////   
+// Scalar Functions //
+//////////////////////
+
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p lower_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>*j < value</tt>. 
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>*i < value</tt>.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin()
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 1
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 8); // returns input.begin() + 4
+ *  thrust::lower_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value);
+
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p lower_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>*j < value</tt>. 
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>*i < value</tt>.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+ForwardIterator lower_bound(ForwardIterator first, 
+                            ForwardIterator last,
+                            const LessThanComparable& value);
+
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p lower_bound uses function object \c comp for comparison 
+ * and returns the furthermost iterator \c i in <tt>[first, last)</tt>
+ * such that, for every iterator \c j in <tt>[first, i)</tt>, 
+ * <tt>comp(*j, value)</tt> is \c true. 
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(*i, value)</tt> is \c true.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp);
+
+
+/*! \p lower_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the first position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p lower_bound uses function object \c comp for comparison 
+ * and returns the furthermost iterator \c i in <tt>[first, last)</tt>
+ * such that, for every iterator \c j in <tt>[first, i)</tt>, 
+ * <tt>comp(*j, value)</tt> is \c true. 
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(*i, value)</tt> is \c true.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::lower_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin()
+ *  thrust::lower_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::lower_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::lower_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.begin() + 4
+ *  thrust::lower_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+ForwardIterator lower_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value, 
+                            StrictWeakOrdering comp);
+
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p upper_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>value < *j</tt>
+ * is \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>value < *i</tt> is \c false.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelism:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 0); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 2); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 8); // returns input.end()
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value);
+
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p upper_bound uses <tt>operator<</tt> for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>value < *j</tt>
+ * is \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return The furthermost iterator \c i, such that <tt>value < *i</tt> is \c false.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(input.begin(), input.end(), 0); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 1); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 2); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 3); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 8); // returns input.end()
+ *  thrust::upper_bound(input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+ForwardIterator upper_bound(ForwardIterator first, 
+                            ForwardIterator last,
+                            const LessThanComparable& value);
+
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p upper_bound uses function object \c comp for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>comp(value, *j)</tt>
+ * is \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(value, *i)</tt> is \c false.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
+ *  thrust::upper_bound(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp);
+
+/*! \p upper_bound is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * Specifically, it returns the last position where value could be
+ * inserted without violating the ordering. This version of 
+ * \p upper_bound uses function object \c comp for comparison and returns
+ * the furthermost iterator \c i in <tt>[first, last)</tt> such that,
+ * for every iterator \c j in <tt>[first, i)</tt>, <tt>comp(value, *j)</tt>
+ * is \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return The furthermost iterator \c i, such that <tt>comp(value, *i)</tt> is \c false.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::upper_bound(input.begin(), input.end(), 0, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 1, thrust::less<int>()); // returns input.begin() + 1
+ *  thrust::upper_bound(input.begin(), input.end(), 2, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 3, thrust::less<int>()); // returns input.begin() + 2
+ *  thrust::upper_bound(input.begin(), input.end(), 8, thrust::less<int>()); // returns input.end()
+ *  thrust::upper_bound(input.begin(), input.end(), 9, thrust::less<int>()); // returns input.end()
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+ForwardIterator upper_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value, 
+                            StrictWeakOrdering comp);
+
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if 
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that 
+ * <tt>*i < value</tt> and <tt>value < *i</tt> are both \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 0); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 1); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 2); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 3); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 8); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 9); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first, 
+                   ForwardIterator last,
+                   const LessThanComparable& value);
+
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if 
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that 
+ * <tt>*i < value</tt> and <tt>value < *i</tt> are both \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(input.begin(), input.end(), 0); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 1); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 2); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 3); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 8); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 9); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class LessThanComparable>
+bool binary_search(ForwardIterator first, 
+                   ForwardIterator last,
+                   const LessThanComparable& value);
+
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if 
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that 
+ * <tt>comp(*i, value)</tt> and <tt>comp(value, *i)</tt> are both \c false.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns false
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns true
+ *  thrust::binary_search(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value, 
+                   StrictWeakOrdering comp);
+
+
+/*! \p binary_search is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. 
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  Specifically, this version returns \c true if and only if 
+ * there exists an iterator \c i in <tt>[first, last)</tt> such that 
+ * <tt>comp(*i, value)</tt> and <tt>comp(value, *i)</tt> are both \c false.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return \c true if an equivalent element exists in <tt>[first, last)</tt>, otherwise \c false.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::binary_search(input.begin(), input.end(), 0, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 1, thrust::less<int>()); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 2, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 3, thrust::less<int>()); // returns false
+ *  thrust::binary_search(input.begin(), input.end(), 8, thrust::less<int>()); // returns true
+ *  thrust::binary_search(input.begin(), input.end(), 9, thrust::less<int>()); // returns false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+bool binary_search(ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value, 
+                   StrictWeakOrdering comp);
+
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The 
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the 
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that 
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property. 
+ *
+ * This version of \p equal_range returns a \p pair of iterators 
+ * <tt>[i, j)</tt>, where \c i is the furthermost iterator in 
+ * <tt>[first, last)</tt> such that, for every iterator \c k in 
+ * <tt>[first, i)</tt>, <tt>*k < value</tt>.  \c j is the furthermost
+ * iterator in <tt>[first, last)</tt> such that, for every iterator 
+ * \c k in <tt>[first, j)</tt>, <tt>value < *k</tt> is \c false. 
+ * For every iterator \c k in <tt>[i, j)</tt>, neither 
+ * <tt>value < *k</tt> nor <tt>*k < value</tt> is \c true.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() + 1)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() + 2)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 9); // returns [input.end(), input.end)
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value);
+
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The 
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the 
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that 
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property. 
+ *
+ * This version of \p equal_range returns a \p pair of iterators 
+ * <tt>[i, j)</tt>, where \c i is the furthermost iterator in 
+ * <tt>[first, last)</tt> such that, for every iterator \c k in 
+ * <tt>[first, i)</tt>, <tt>*k < value</tt>.  \c j is the furthermost
+ * iterator in <tt>[first, last)</tt> such that, for every iterator 
+ * \c k in <tt>[first, j)</tt>, <tt>value < *k</tt> is \c false. 
+ * For every iterator \c k in <tt>[i, j)</tt>, neither 
+ * <tt>value < *k</tt> nor <tt>*k < value</tt> is \c true.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam LessThanComparable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>. 
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(input.begin(), input.end(), 0); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 1); // returns [input.begin() + 1, input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 2); // returns [input.begin() + 1, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 3); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 8); // returns [input.begin() + 4, input.end)
+ *  thrust::equal_range(input.begin(), input.end(), 9); // returns [input.end(), input.end)
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class LessThanComparable>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value);
+
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The 
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the 
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that 
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property. 
+ *
+ * This version of \p equal_range returns a \p pair of iterators 
+ * <tt>[i, j)</tt>. \c i is the furthermost iterator in 
+ * <tt>[first, last)</tt> such that, for every iterator \c k in 
+ * <tt>[first, i)</tt>, <tt>comp(*k, value)</tt> is \c true.
+ * \c j is the furthermost iterator in <tt>[first, last)</tt> such
+ * that, for every iterator \c k in <tt>[first, last)</tt>, 
+ * <tt>comp(value, *k)</tt> is \c false. For every iterator \c k 
+ * in <tt>[i, j)</tt>, neither <tt>comp(value, *k)</tt> nor 
+ * <tt>comp(*k, value)</tt> is \c true.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 1, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 1)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 2, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 2)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 3, thrust::less<int>()); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 8, thrust::less<int>()); // returns [input.begin() + 4, input.end)
+ *  thrust::equal_range(thrust::device, input.begin(), input.end(), 9, thrust::less<int>()); // returns [input.end(), input.end)
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp);
+
+
+/*! \p equal_range is a version of binary search: it attempts to find
+ * the element value in an ordered range <tt>[first, last)</tt>. The 
+ * value returned by \p equal_range is essentially a combination of
+ * the values returned by \p lower_bound and \p upper_bound: it returns
+ * a \p pair of iterators \c i and \c j such that \c i is the first
+ * position where value could be inserted without violating the 
+ * ordering and \c j is the last position where value could be inserted
+ * without violating the ordering. It follows that every element in the
+ * range <tt>[i, j)</tt> is equivalent to value, and that 
+ * <tt>[i, j)</tt> is the largest subrange of <tt>[first, last)</tt> that
+ * has this property. 
+ *
+ * This version of \p equal_range returns a \p pair of iterators 
+ * <tt>[i, j)</tt>. \c i is the furthermost iterator in 
+ * <tt>[first, last)</tt> such that, for every iterator \c k in 
+ * <tt>[first, i)</tt>, <tt>comp(*k, value)</tt> is \c true.
+ * \c j is the furthermost iterator in <tt>[first, last)</tt> such
+ * that, for every iterator \c k in <tt>[first, last)</tt>, 
+ * <tt>comp(value, *k)</tt> is \c false. For every iterator \c k 
+ * in <tt>[i, j)</tt>, neither <tt>comp(value, *k)</tt> nor 
+ * <tt>comp(*k, value)</tt> is \c true.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param value The value to be searched.
+ *  \param comp The comparison operator.
+ *  \return A \p pair of iterators <tt>[i, j)</tt> that define the range of equivalent elements.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam T is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal_range
+ *  to search for values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::equal_range(input.begin(), input.end(), 0, thrust::less<int>()); // returns [input.begin(), input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 1, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 1)
+ *  thrust::equal_range(input.begin(), input.end(), 2, thrust::less<int>()); // returns [input.begin() + 1, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 3, thrust::less<int>()); // returns [input.begin() + 2, input.begin() + 2)
+ *  thrust::equal_range(input.begin(), input.end(), 8, thrust::less<int>()); // returns [input.begin() + 4, input.end)
+ *  thrust::equal_range(input.begin(), input.end(), 9, thrust::less<int>()); // returns [input.end(), input.end)
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal_range
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class T, class StrictWeakOrdering>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp);
+
+
+/*! \addtogroup vectorized_binary_search Vectorized Searches
+ *  \ingroup binary_search
+ *  \{
+ */
+
+
+//////////////////////
+// Vector Functions //
+//////////////////////
+
+
+/*! \p lower_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result);
+
+
+/*! \p lower_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator lower_bound(ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result);
+
+
+/*! \p lower_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of 
+ * \p lower_bound uses function object \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(), 
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result,
+                           StrictWeakOrdering comp);
+
+
+/*! \p lower_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of 
+ * \p lower_bound uses function object \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p lower_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::lower_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(), 
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [0, 1, 1, 2, 4, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator lower_bound(ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result,
+                           StrictWeakOrdering comp);
+
+
+/*! \p upper_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of last position where value could
+ * be inserted without violating the ordering.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result);
+
+
+/*! \p upper_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of last position where value could
+ * be inserted without violating the ordering.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(),
+ *                      output.begin());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator upper_bound(ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result);
+
+
+/*! \p upper_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of 
+ * \p upper_bound uses function object \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(thrust::device,
+ *                      input.begin(), input.end(),
+ *                      values.begin(), values.end(), 
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result,
+                           StrictWeakOrdering comp);
+
+
+/*! \p upper_bound is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * Specifically, it returns the index of first position where value could
+ * be inserted without violating the ordering.  This version of 
+ * \p upper_bound uses function object \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is comparable to \p ForwardIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and \c ForwardIterator's difference_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p upper_bound
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<unsigned int> output(6);
+ *
+ *  thrust::upper_bound(input.begin(), input.end(),
+ *                      values.begin(), values.end(), 
+ *                      output.begin(),
+ *                      thrust::less<int>());
+ *
+ *  // output is now [1, 1, 2, 2, 5, 5]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/upper_bound
+ *  \see \p lower_bound
+ *  \see \p equal_range
+ *  \see \p binary_search
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator upper_bound(ForwardIterator first, 
+                           ForwardIterator last,
+                           InputIterator values_first, 
+                           InputIterator values_last,
+                           OutputIterator result,
+                           StrictWeakOrdering comp);
+
+
+/*! \p binary_search is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and bool is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(thrust::device,
+ *                        input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first, 
+                             ForwardIterator last,
+                             InputIterator values_first, 
+                             InputIterator values_last,
+                             OutputIterator result);
+
+
+/*! \p binary_search is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and bool is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator>
+OutputIterator binary_search(ForwardIterator first, 
+                             ForwardIterator last,
+                             InputIterator values_first, 
+                             InputIterator values_last,
+                             OutputIterator result);
+
+
+/*! \p binary_search is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  This version of \p binary_search uses function object 
+ * \c comp for comparison.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and bool is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(thrust::device,
+ *                        input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin(),
+ *                        thrust::less<T>());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first, 
+                             ForwardIterator last,
+                             InputIterator values_first, 
+                             InputIterator values_last,
+                             OutputIterator result,
+                             StrictWeakOrdering comp);
+
+
+/*! \p binary_search is a vectorized version of binary search: for each 
+ * iterator \c v in <tt>[values_first, values_last)</tt> it attempts to
+ * find the value <tt>*v</tt> in an ordered range <tt>[first, last)</tt>.
+ * It returns \c true if an element that is equivalent to \c value 
+ * is present in <tt>[first, last)</tt> and \c false if no such element
+ * exists.  This version of \p binary_search uses function object 
+ * \c comp for comparison.
+ *
+ *  \param first The beginning of the ordered sequence.
+ *  \param last The end of the ordered sequence.
+ *  \param values_first The beginning of the search values sequence.
+ *  \param values_last The end of the search values sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param comp The comparison operator.
+ * 
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *                        and \c InputIterator's \c value_type is <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThanComparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *                        and bool is convertible to \c OutputIterator's \c value_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p binary_search
+ *  to search for multiple values in a ordered range.
+ *
+ *  \code
+ *  #include <thrust/binary_search.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<int> input(5);
+ *
+ *  input[0] = 0;
+ *  input[1] = 2;
+ *  input[2] = 5;
+ *  input[3] = 7;
+ *  input[4] = 8;
+ *
+ *  thrust::device_vector<int> values(6);
+ *  values[0] = 0; 
+ *  values[1] = 1;
+ *  values[2] = 2;
+ *  values[3] = 3;
+ *  values[4] = 8;
+ *  values[5] = 9;
+ *
+ *  thrust::device_vector<bool> output(6);
+ *
+ *  thrust::binary_search(input.begin(), input.end(),
+ *                        values.begin(), values.end(),
+ *                        output.begin(),
+ *                        thrust::less<T>());
+ *
+ *  // output is now [true, false, true, false, true, false]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/binary_search
+ *  \see \p lower_bound
+ *  \see \p upper_bound
+ *  \see \p equal_range
+ */
+template <class ForwardIterator, class InputIterator, class OutputIterator, class StrictWeakOrdering>
+OutputIterator binary_search(ForwardIterator first, 
+                             ForwardIterator last,
+                             InputIterator values_first, 
+                             InputIterator values_last,
+                             OutputIterator result,
+                             StrictWeakOrdering comp);
+
+
+/*! \} // end vectorized_binary_search
+ */
+
+
+/*! \} // end binary_search
+ */
+
+
+/*! \} // end searching
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/binary_search.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/complex.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/complex.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c0be0d61d96353e2021d23af17775015af533b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/complex.h
@@ -0,0 +1,1047 @@
+/*
+ *  Copyright 2008-2019 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.
+ */
+
+/*! \file complex.h
+ *  \brief Complex numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <cmath>
+#include <complex>
+#include <sstream>
+#include <thrust/detail/type_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+#  define THRUST_STD_COMPLEX_REAL(z) \
+    reinterpret_cast< \
+      const typename thrust::detail::remove_reference<decltype(z)>::type::value_type (&)[2] \
+    >(z)[0]
+#  define THRUST_STD_COMPLEX_IMAG(z) \
+    reinterpret_cast< \
+      const typename thrust::detail::remove_reference<decltype(z)>::type::value_type (&)[2] \
+    >(z)[1]
+#  define THRUST_STD_COMPLEX_DEVICE __device__
+#else
+#  define THRUST_STD_COMPLEX_REAL(z) (z).real()
+#  define THRUST_STD_COMPLEX_IMAG(z) (z).imag()
+#  define THRUST_STD_COMPLEX_DEVICE
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+/*
+ *  Calls to the standard math library from inside the thrust namespace
+ *  with real arguments require explicit scope otherwise they will fail
+ *  to resolve as it will find the equivalent complex function but then
+ *  fail to match the template, and give up looking for other scopes.
+ */
+
+
+/*! \addtogroup numerics
+ *  \{
+ */
+
+/*! \addtogroup complex_numbers Complex Numbers
+ *  \{
+ */
+
+/*! \cond
+ */
+
+namespace detail
+{
+
+template <typename T, std::size_t Align>
+struct complex_storage;
+
+#if THRUST_CPP_DIALECT >= 2011                                                    \
+  && (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                       \
+  && (THRUST_GCC_VERSION >= 40800)
+  // C++11 implementation, excluding GCC 4.7, which doesn't have `alignas`.
+  template <typename T, std::size_t Align>
+  struct complex_storage
+  {
+    struct alignas(Align) type { T x; T y; };
+  };
+#elif  (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)                    \
+    || (   (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                 \
+        && (THRUST_GCC_VERSION < 40600))
+  // C++03 implementation for MSVC and GCC <= 4.5.
+  //
+  // We have to implement `aligned_type` with specializations for MSVC
+  // and GCC 4.2 and older because they require literals as arguments to
+  // their alignment attribute.
+
+  #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)
+    // MSVC implementation.
+    #define THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(X)                   \
+      template <typename T>                                                   \
+      struct complex_storage<T, X>                                            \
+      {                                                                       \
+        __declspec(align(X)) struct type { T x; T y; };                       \
+      };                                                                      \
+      /**/
+  #else
+    // GCC <= 4.2 implementation.
+    #define THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(X)                   \
+      template <typename T>                                                   \
+      struct complex_storage<T, X>                                            \
+      {                                                                       \
+        struct type { T x; T y; } __attribute__((aligned(X)));                \
+      };                                                                      \
+      /**/
+  #endif
+
+  // The primary template is a fallback, which doesn't specify any alignment.
+  // It's only used when T is very large and we're using an older compilers
+  // which we have to fully specialize each alignment case.
+  template <typename T, std::size_t Align>
+  struct complex_storage
+  {
+    T x; T y;
+  };
+
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(1);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(2);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(4);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(8);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(16);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(32);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(64);
+  THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION(128);
+
+  #undef THRUST_DEFINE_COMPLEX_STORAGE_SPECIALIZATION
+#else
+  // C++03 implementation for GCC > 4.5, Clang, PGI, ICPC, and xlC.
+  template <typename T, std::size_t Align>
+  struct complex_storage
+  {
+    struct type { T x; T y; } __attribute__((aligned(Align)));
+  };
+#endif
+
+} // end namespace detail
+
+/*! \endcond
+ */
+
+/*! \p complex is the Thrust equivalent to <tt>std::complex</tt>. It is
+ *  functionally identical to it, but can also be used in device code which
+ *  <tt>std::complex</tt> currently cannot.
+ *
+ *  \tparam T The type used to hold the real and imaginary parts. Should be
+ *  <tt>float</tt> or <tt>double</tt>. Others types are not supported.
+ *
+ */
+template <typename T>
+struct complex
+{
+public:
+
+  /*! \p value_type is the type of \p complex's real and imaginary parts.
+   */
+  typedef T value_type;
+
+
+
+  /* --- Constructors --- */
+
+  /*! Construct a complex number with an imaginary part of 0.
+   *
+   *  \param re The real part of the number.
+   */
+  __host__ __device__
+  complex(const T& re);
+
+  /*! Construct a complex number from its real and imaginary parts.
+   *
+   *  \param re The real part of the number.
+   *  \param im The imaginary part of the number.
+   */
+  __host__ __device__
+  complex(const T& re, const T& im);
+
+#if THRUST_CPP_DIALECT >= 2011
+  /*! Default construct a complex number.
+   */
+  complex() = default;
+
+  /*! This copy constructor copies from a \p complex with a type that is
+   *  convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  complex(const complex<T>& z) = default;
+#else
+  /*! Default construct a complex number.
+   */
+  __host__ __device__
+  complex();
+
+  /*! This copy constructor copies from a \p complex with a type that is
+   *  convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  __host__ __device__
+  complex(const complex<T>& z);
+#endif
+
+  /*! This converting copy constructor copies from a \p complex with a type
+   *  that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex(const complex<U>& z);
+
+  /*! This converting copy constructor copies from a <tt>std::complex</tt> with
+   *  a type that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  __host__ THRUST_STD_COMPLEX_DEVICE
+  complex(const std::complex<T>& z);
+
+  /*! This converting copy constructor copies from a <tt>std::complex</tt> with
+   *  a type that is convertible to this \p complex's \c value_type.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ THRUST_STD_COMPLEX_DEVICE
+  complex(const std::complex<U>& z);
+
+
+
+  /* --- Assignment Operators --- */
+
+  /*! Assign `re` to the real part of this \p complex and set the imaginary part
+   *  to 0.
+   *
+   *  \param re The real part of the number.
+   */
+  __host__ __device__
+  complex& operator=(const T& re);
+
+#if THRUST_CPP_DIALECT >= 2011
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  complex& operator=(const complex<T>& z) = default;
+#else
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  __host__ __device__
+  complex& operator=(const complex<T>& z);
+#endif
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex& operator=(const complex<U>& z);
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   */
+  __host__ THRUST_STD_COMPLEX_DEVICE
+  complex& operator=(const std::complex<T>& z);
+
+  /*! Assign `z.real()` and `z.imag()` to the real and imaginary parts of this
+   *  \p complex respectively.
+   *
+   *  \param z The \p complex to copy from.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ THRUST_STD_COMPLEX_DEVICE
+  complex& operator=(const std::complex<U>& z);
+
+
+  /* --- Compound Assignment Operators --- */
+
+  /*! Adds a \p complex to this \p complex and assigns the result to this
+   *  \p complex.
+   *
+   *  \param z The \p complex to be added.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator+=(const complex<U>& z);
+
+  /*! Subtracts a \p complex from this \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The \p complex to be subtracted.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator-=(const complex<U>& z);
+
+  /*! Multiplies this \p complex by another \p complex and assigns the result
+   *  to this \p complex.
+   *
+   *  \param z The \p complex to be multiplied.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator*=(const complex<U>& z);
+
+  /*! Divides this \p complex by another \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The \p complex to be divided.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator/=(const complex<U>& z);
+
+  /*! Adds a scalar to this \p complex and assigns the result to this
+   *  \p complex.
+   *
+   *  \param z The \p complex to be added.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator+=(const U& z);
+
+  /*! Subtracts a scalar from this \p complex and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The scalar to be subtracted.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator-=(const U& z);
+
+  /*! Multiplies this \p complex by a scalar and assigns the result
+   *  to this \p complex.
+   *
+   *  \param z The scalar to be multiplied.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator*=(const U& z);
+
+  /*! Divides this \p complex by a scalar and assigns the result to
+   *  this \p complex.
+   *
+   *  \param z The scalar to be divided.
+   *
+   *  \tparam U is convertible to \c value_type.
+   */
+  template <typename U>
+  __host__ __device__
+  complex<T>& operator/=(const U& z);
+
+
+
+  /* --- Getter functions ---
+   * The volatile ones are there to help for example
+   * with certain reductions optimizations
+   */
+
+  /*! Returns the real part of this \p complex.
+   */
+  __host__ __device__
+  T real() const volatile { return data.x; }
+
+  /*! Returns the imaginary part of this \p complex.
+   */
+  __host__ __device__
+  T imag() const volatile { return data.y; }
+
+  /*! Returns the real part of this \p complex.
+   */
+  __host__ __device__
+  T real() const { return data.x; }
+
+  /*! Returns the imaginary part of this \p complex.
+   */
+  __host__ __device__
+  T imag() const { return data.y; }
+
+
+
+  /* --- Setter functions ---
+   * The volatile ones are there to help for example
+   * with certain reductions optimizations
+   */
+
+  /*! Sets the real part of this \p complex.
+   *
+   *  \param re The new real part of this \p complex.
+   */
+  __host__ __device__
+  void real(T re) volatile { data.x = re; }
+
+  /*! Sets the imaginary part of this \p complex.
+   *
+   *  \param im The new imaginary part of this \p complex.e
+   */
+  __host__ __device__
+  void imag(T im) volatile { data.y = im; }
+
+  /*! Sets the real part of this \p complex.
+   *
+   *  \param re The new real part of this \p complex.
+   */
+  __host__ __device__
+  void real(T re) { data.x = re; }
+
+  /*! Sets the imaginary part of this \p complex.
+   *
+   *  \param im The new imaginary part of this \p complex.
+   */
+  __host__ __device__
+  void imag(T im) { data.y = im; }
+
+
+
+  /* --- Casting functions --- */
+
+  /*! Casts this \p complex to a <tt>std::complex</tt> of the same type.
+   */
+  __host__
+  operator std::complex<T>() const { return std::complex<T>(real(), imag()); }
+
+private:
+  typename detail::complex_storage<T, sizeof(T) * 2>::type data;
+};
+
+
+/* --- General Functions --- */
+
+/*! Returns the magnitude (also known as absolute value) of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the absolute value.
+ */
+template<typename T>
+__host__ __device__
+T abs(const complex<T>& z);
+
+/*! Returns the phase angle (also known as argument) in radians of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the phase angle.
+ */
+template <typename T>
+__host__ __device__
+T arg(const complex<T>& z);
+
+/*! Returns the square of the magnitude of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the norm.
+ */
+template <typename T>
+__host__ __device__
+T norm(const complex<T>& z);
+
+/*! Returns the complex conjugate of a \p complex.
+ *
+ *  \param z The \p complex from which to calculate the complex conjugate.
+ */
+template <typename T>
+__host__ __device__
+complex<T> conj(const complex<T>& z);
+
+/*! Returns a \p complex with the specified magnitude and phase.
+ *
+ *  \param m The magnitude of the returned \p complex.
+ *  \param theta The phase of the returned \p complex in radians.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+polar(const T0& m, const T1& theta = T1());
+
+/*! Returns the projection of a \p complex on the Riemann sphere.
+ *  For all finite \p complex it returns the argument. For \p complexs
+ *  with a non finite part returns (INFINITY,+/-0) where the sign of
+ *  the zero matches the sign of the imaginary part of the argument.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> proj(const T& z);
+
+
+
+/* --- Binary Arithmetic operators --- */
+
+/*! Adds two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const complex<T0>& x, const complex<T1>& y);
+
+/*! Adds a scalar to a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const complex<T0>& x, const T1& y);
+
+/*! Adds a \p complex number to a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const T0& x, const complex<T1>& y);
+
+/*! Subtracts two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex (minuend).
+ *  \param y The second \p complex (subtrahend).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const complex<T0>& x, const complex<T1>& y);
+
+/*! Subtracts a scalar from a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The \p complex (minuend).
+ *  \param y The scalar (subtrahend).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const complex<T0>& x, const T1& y);
+
+/*! Subtracts a \p complex number from a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar (minuend).
+ *  \param y The \p complex (subtrahend).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const T0& x, const complex<T1>& y);
+
+/*! Multiplies two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const complex<T0>& x, const complex<T1>& y);
+
+/*! Multiplies a \p complex number by a scalar.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const complex<T0>& x, const T1& y);
+
+/*! Multiplies a scalar by a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const T0& x, const complex<T1>& y);
+
+/*! Divides two \p complex numbers.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The numerator (dividend).
+ *  \param y The denomimator (divisor).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const complex<T0>& x, const complex<T1>& y);
+
+/*! Divides a \p complex number by a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The complex numerator (dividend).
+ *  \param y The scalar denomimator (divisor).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const complex<T0>& x, const T1& y);
+
+/*! Divides a scalar by a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The scalar numerator (dividend).
+ *  \param y The complex denomimator (divisor).
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const T0& x, const complex<T1>& y);
+
+
+
+/* --- Unary Arithmetic operators --- */
+
+/*! Unary plus, returns its \p complex argument.
+ *
+ *  \param y The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T>
+operator+(const complex<T>& y);
+
+/*! Unary minus, returns the additive inverse (negation) of its \p complex
+ * argument.
+ *
+ *  \param y The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T>
+operator-(const complex<T>& y);
+
+
+
+/* --- Exponential Functions --- */
+
+/*! Returns the complex exponential of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> exp(const complex<T>& z);
+
+/*! Returns the complex natural logarithm of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> log(const complex<T>& z);
+
+/*! Returns the complex base 10 logarithm of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> log10(const complex<T>& z);
+
+
+
+/* --- Power Functions --- */
+
+/*! Returns a \p complex number raised to another.
+ *
+ *  The value types of the two \p complex types should be compatible and the
+ *  type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns a \p complex number raised to a scalar.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const complex<T0>& x, const T1& y);
+
+/*! Returns a scalar raised to a \p complex number.
+ *
+ *  The value type of the \p complex should be compatible with the scalar and
+ *  the type of the returned \p complex is the promoted type of the two arguments.
+ *
+ *  \param x The base.
+ *  \param y The exponent.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const T0& x, const complex<T1>& y);
+
+/*! Returns the complex square root of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> sqrt(const complex<T>& z);
+
+
+/* --- Trigonometric Functions --- */
+
+/*! Returns the complex cosine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> cos(const complex<T>& z);
+
+/*! Returns the complex sine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> sin(const complex<T>& z);
+
+/*! Returns the complex tangent of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> tan(const complex<T>& z);
+
+
+
+/* --- Hyperbolic Functions --- */
+
+/*! Returns the complex hyperbolic cosine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> cosh(const complex<T>& z);
+
+/*! Returns the complex hyperbolic sine of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> sinh(const complex<T>& z);
+
+/*! Returns the complex hyperbolic tangent of a \p complex number.
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> tanh(const complex<T>& z);
+
+
+
+/* --- Inverse Trigonometric Functions --- */
+
+/*! Returns the complex arc cosine of a \p complex number.
+ *
+ *  The range of the real part of the result is [0, Pi] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> acos(const complex<T>& z);
+
+/*! Returns the complex arc sine of a \p complex number.
+ *
+ *  The range of the real part of the result is [-Pi/2, Pi/2] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> asin(const complex<T>& z);
+
+/*! Returns the complex arc tangent of a \p complex number.
+ *
+ *  The range of the real part of the result is [-Pi/2, Pi/2] and
+ *  the range of the imaginary part is [-inf, +inf]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> atan(const complex<T>& z);
+
+
+
+/* --- Inverse Hyperbolic Functions --- */
+
+/*! Returns the complex inverse hyperbolic cosine of a \p complex number.
+ *
+ *  The range of the real part of the result is [0, +inf] and
+ *  the range of the imaginary part is [-Pi, Pi]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> acosh(const complex<T>& z);
+
+/*! Returns the complex inverse hyperbolic sine of a \p complex number.
+ *
+ *  The range of the real part of the result is [-inf, +inf] and
+ *  the range of the imaginary part is [-Pi/2, Pi/2]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> asinh(const complex<T>& z);
+
+/*! Returns the complex inverse hyperbolic tangent of a \p complex number.
+ *
+ *  The range of the real part of the result is [-inf, +inf] and
+ *  the range of the imaginary part is [-Pi/2, Pi/2]
+ *
+ *  \param z The \p complex argument.
+ */
+template <typename T>
+__host__ __device__
+complex<T> atanh(const complex<T>& z);
+
+
+
+/* --- Stream Operators --- */
+
+/*! Writes to an output stream a \p complex number in the form (real, imaginary).
+ *
+ *  \param os The output stream.
+ *  \param z The \p complex number to output.
+ */
+template <typename T, typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const complex<T>& z);
+
+/*! Reads a \p complex number from an input stream.
+ *
+ *  The recognized formats are:
+ * - real
+ * - (real)
+ * - (real, imaginary)
+ *
+ * The values read must be convertible to the \p complex's \c value_type
+ *
+ *  \param is The input stream.
+ *  \param z The \p complex number to set.
+ */
+template <typename T, typename CharT, typename Traits>
+__host__
+std::basic_istream<CharT, Traits>&
+operator>>(std::basic_istream<CharT, Traits>& is, complex<T>& z);
+
+
+
+/* --- Equality Operators --- */
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator==(const complex<T0>& x, const std::complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are equal and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator==(const std::complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is zero and
+ *  the real part is equal to the scalar. Returns false otherwise.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const T0& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is zero and
+ *  the real part is equal to the scalar. Returns false otherwise.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const complex<T0>& x, const T1& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator!=(const complex<T0>& x, const std::complex<T1>& y);
+
+/*! Returns true if two \p complex numbers are different and false otherwise.
+ *
+ *  \param x The first \p complex.
+ *  \param y The second \p complex.
+ */
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator!=(const std::complex<T0>& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is not zero or
+ *  the real part is different from the scalar. Returns false otherwise.
+ *
+ *  \param x The scalar.
+ *  \param y The \p complex.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const T0& x, const complex<T1>& y);
+
+/*! Returns true if the imaginary part of the \p complex number is not zero or
+ *  the real part is different from the scalar. Returns false otherwise.
+ *
+ *  \param x The \p complex.
+ *  \param y The scalar.
+ */
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const complex<T0>& x, const T1& y);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/complex/complex.inl>
+
+#undef THRUST_STD_COMPLEX_REAL
+#undef THRUST_STD_COMPLEX_IMAG
+#undef THRUST_STD_COMPLEX_DEVICE
+
+/*! \} // complex_numbers
+ */
+
+/*! \} // numerics
+ */
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..99d488174dd6f0b836ba822f1d1c46525453fb91
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/copy.h
@@ -0,0 +1,512 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/copy.h
+ *  \brief Copies elements from one range to another
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup copying
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p copy copies elements from the range [\p first, \p last) to the range
+ *  [\p result, \p result + (\p last - \p first)). That is, it performs
+ *  the assignments *\p result = *\p first, *(\p result + \c 1) = *(\p first + \c 1),
+ *  and so on. Generally, for every integer \c n from \c 0 to \p last - \p first, \p copy
+ *  performs the assignment *(\p result + \c n) = *(\p first + \c n). Unlike
+ *  \c std::copy, \p copy offers no guarantee on order of operation.  As a result,
+ *  calling \p copy with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + (\p last - \p first).
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to copy.
+ *  \param last The end of the sequence to copy.
+ *  \param result The destination sequence.
+ *  \return The end of the destination sequence.
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, last)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  thrust::device_vector<int> vec0(100);
+ *  thrust::device_vector<int> vec1(100);
+ *  ...
+ *
+ *  thrust::copy(thrust::device, vec0.begin(), vec0.end(), vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+  OutputIterator copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+
+/*! \p copy_n copies elements from the range <tt>[first, first + n)</tt> to the range
+ *  <tt>[result, result + n)</tt>. That is, it performs the assignments <tt>*result = *first, *(result + 1) = *(first + 1)</tt>,
+ *  and so on. Generally, for every integer \c i from \c 0 to \c n, \p copy
+ *  performs the assignment *(\p result + \c i) = *(\p first + \c i). Unlike
+ *  \c std::copy_n, \p copy_n offers no guarantee on order of operation. As a result,
+ *  calling \p copy_n with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + \p n.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to copy.
+ *  \param n The number of elements to copy.
+ *  \param result The beginning destination range.
+ *  \return The end of the destination range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam Size is an integral type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, first + n)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  size_t n = 100;
+ *  thrust::device_vector<int> vec0(n);
+ *  thrust::device_vector<int> vec1(n);
+ *  ...
+ *  thrust::copy_n(thrust::device, vec0.begin(), n, vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy_n
+ *  \see thrust::copy
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename OutputIterator>
+__host__ __device__
+  OutputIterator copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+
+	
+/*! \p copy copies elements from the range [\p first, \p last) to the range
+ *  [\p result, \p result + (\p last - \p first)). That is, it performs
+ *  the assignments *\p result = *\p first, *(\p result + \c 1) = *(\p first + \c 1),
+ *  and so on. Generally, for every integer \c n from \c 0 to \p last - \p first, \p copy
+ *  performs the assignment *(\p result + \c n) = *(\p first + \c n). Unlike
+ *  \c std::copy, \p copy offers no guarantee on order of operation.  As a result,
+ *  calling \p copy with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + (\p last - \p first).
+ *
+ *  \param first The beginning of the sequence to copy.
+ *  \param last The end of the sequence to copy.
+ *  \param result The destination sequence.
+ *  \return The end of the destination sequence.
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, last)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *
+ *  thrust::device_vector<int> vec0(100);
+ *  thrust::device_vector<int> vec1(100);
+ *  ...
+ *
+ *  thrust::copy(vec0.begin(), vec0.end(),
+ *               vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ */
+template<typename InputIterator, typename OutputIterator>
+  OutputIterator copy(InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+/*! \p copy_n copies elements from the range <tt>[first, first + n)</tt> to the range
+ *  <tt>[result, result + n)</tt>. That is, it performs the assignments <tt>*result = *first, *(result + 1) = *(first + 1)</tt>,
+ *  and so on. Generally, for every integer \c i from \c 0 to \c n, \p copy
+ *  performs the assignment *(\p result + \c i) = *(\p first + \c i). Unlike
+ *  \c std::copy_n, \p copy_n offers no guarantee on order of operation. As a result,
+ *  calling \p copy_n with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + \p n.
+ *
+ *  \param first The beginning of the range to copy.
+ *  \param n The number of elements to copy.
+ *  \param result The beginning destination range.
+ *  \return The end of the destination range.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam Size is an integral type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, first + n)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  size_t n = 100;
+ *  thrust::device_vector<int> vec0(n);
+ *  thrust::device_vector<int> vec1(n);
+ *  ...
+ *  thrust::copy_n(vec0.begin(), n, vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy_n
+ *  \see thrust::copy
+ */
+template<typename InputIterator, typename Size, typename OutputIterator>
+  OutputIterator copy_n(InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+/*! \} // end copying
+ */
+
+/*! \addtogroup stream_compaction
+ *  \{
+ */
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element which causes \p pred
+ *  to be \c false is not copied. \p copy_if is stable, meaning that the relative
+ *  order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(first+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  The algorithm's execution is parallelized as determined by \p system.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[first, last)</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[first, last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy even numbers to an output range using the \p thrust::host parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(thrust::host, V, V + N, result, is_even());
+ *
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, 0, 0, 2}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element which causes \p pred
+ *  to \c false is not copied. \p copy_if is stable, meaning that the relative
+ *  order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(first+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[first, last)</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[first, last)</tt>.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy even numbers to an output range.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(V, V + N, result, is_even());
+ *
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, 0, 0, 2}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c false is not copied. \p copy_if is stable, meaning
+ *  that the relative order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(stencil+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last-first))</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[stencil, stencil + (last-first))</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/OutputIterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *  \pre The ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy numbers to an output range when corresponding stencil elements are even using the \p thrust::host execution policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int N = 6;
+ *  int data[N]    = { 0, 1,  2, 3, 4, 5};
+ *  int stencil[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(thrust::host, data, data + N, stencil, result, is_even());
+ *
+ *  // data remains    = { 0, 1,  2, 3, 4, 5};
+ *  // stencil remains = {-2, 0, -1, 0, 1, 2};
+ *  // result is now     { 0, 1,  3, 5}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c false is not copied. \p copy_if is stable, meaning
+ *  that the relative order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(stencil+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last-first))</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[stencil, stencil + (last-first))</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/OutputIterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *  \pre The ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy numbers to an output range when corresponding stencil elements are even:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int N = 6;
+ *  int data[N]    = { 0, 1,  2, 3, 4, 5};
+ *  int stencil[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(data, data + N, stencil, result, is_even());
+ *
+ *  // data remains    = { 0, 1,  2, 3, 4, 5};
+ *  // stencil remains = {-2, 0, -1, 0, 1, 2};
+ *  // result is now     { 0, 1,  3, 5}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+/*! \} // end stream_compaction
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.h>
+#include <thrust/detail/copy_if.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/count.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..abf8b2d6c300bc930c2514960e9d421617e02294
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/count.h
@@ -0,0 +1,231 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file count.h
+ *  \brief Counting elements in a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup reductions
+ *  \ingroup algorithms
+ *  \{
+ */
+
+/*! \addtogroup counting
+ *  \ingroup reductions
+ *  \{
+ */
+
+
+/*! \p count finds the number of elements in <tt>[first,last)</tt> that are equal
+ *  to \p value. More precisely, \p count returns the number of iterators \c i in
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be counted.
+ *  \return The number of elements equal to \p value.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be a model of must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam EqualityComparable must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a> and can be compared for equality with \c InputIterator's \c value_type
+ *
+ *  The following code snippet demonstrates how to use \p count to 
+ *  count the number of instances in a range of a value of interest using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  // put 3 1s in a device_vector
+ *  thrust::device_vector<int> vec(5,0);
+ *  vec[1] = 1;
+ *  vec[3] = 1;
+ *  vec[4] = 1;
+ *  
+ *  // count the 1s
+ *  int result = thrust::count(thrust::device, vec.begin(), vec.end(), 1);
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template<typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+__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);
+
+
+
+/*! \p count finds the number of elements in <tt>[first,last)</tt> that are equal
+ *  to \p value. More precisely, \p count returns the number of iterators \c i in
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be counted.
+ *  \return The number of elements equal to \p value.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be a model of must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam EqualityComparable must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a> and can be compared for equality with \c InputIterator's \c value_type
+ *
+ *  The following code snippet demonstrates how to use \p count to 
+ *  count the number of instances in a range of a value of interest.
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  // put 3 1s in a device_vector
+ *  thrust::device_vector<int> vec(5,0);
+ *  vec[1] = 1;
+ *  vec[3] = 1;
+ *  vec[4] = 1;
+ *  
+ *  // count the 1s
+ *  int result = thrust::count(vec.begin(), vec.end(), 1);
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename InputIterator, typename EqualityComparable>
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count(InputIterator first, InputIterator last, const EqualityComparable& value);
+
+
+/*! \p count_if finds the number of elements in <tt>[first,last)</tt> for which 
+ *  a predicate is \c true. More precisely, \p count_if returns the number of iterators
+ *  \c i in <tt>[first, last)</tt> such that <tt>pred(*i) == true</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param pred The predicate.
+ *  \return The number of elements where \p pred is \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of odd numbers in a range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int &x)
+ *    {
+ *      return x & 1;
+ *    }
+ *  };
+ *  ...
+ *  // fill a device_vector with even & odd numbers
+ *  thrust::device_vector<int> vec(5);
+ *  vec[0] = 0;
+ *  vec[1] = 1;
+ *  vec[2] = 2;
+ *  vec[3] = 3;
+ *  vec[4] = 4;
+ *
+ *  // count the odd elements in vec
+ *  int result = thrust::count_if(thrust::device, vec.begin(), vec.end(), is_odd());
+ *  // result == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__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);
+
+
+/*! \p count_if finds the number of elements in <tt>[first,last)</tt> for which 
+ *  a predicate is \c true. More precisely, \p count_if returns the number of iterators
+ *  \c i in <tt>[first, last)</tt> such that <tt>pred(*i) == true</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param pred The predicate.
+ *  \return The number of elements where \p pred is \c true.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p count to
+ *  count the number of odd numbers in a range.
+ *  \code
+ *  #include <thrust/count.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int &x)
+ *    {
+ *      return x & 1;
+ *    }
+ *  };
+ *  ...
+ *  // fill a device_vector with even & odd numbers
+ *  thrust::device_vector<int> vec(5);
+ *  vec[0] = 0;
+ *  vec[1] = 1;
+ *  vec[2] = 2;
+ *  vec[3] = 3;
+ *  vec[4] = 4;
+ *
+ *  // count the odd elements in vec
+ *  int result = thrust::count_if(vec.begin(), vec.end(), is_odd());
+ *  // result == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/count
+ */
+template <typename InputIterator, typename Predicate>
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count_if(InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \} // end counting
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/count.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/adjacent_difference.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/adjacent_difference.inl
new file mode 100644
index 0000000000000000000000000000000000000000..844687cff4c9147ea0b93c7bcee45bb74c2538ae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/adjacent_difference.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>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/adjacent_difference.h>
+#include <thrust/system/detail/adl/adjacent_difference.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator adjacent_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result)
+{
+  using thrust::system::detail::generic::adjacent_difference;
+
+  return adjacent_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end adjacent_difference()
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__
+OutputIterator adjacent_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::adjacent_difference;
+
+  return adjacent_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, binary_op);
+} // end adjacent_difference()
+
+
+template <typename InputIterator, typename OutputIterator>
+OutputIterator adjacent_difference(InputIterator first, InputIterator last,
+                                   OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::adjacent_difference(select_system(system1, system2), first, last, result);
+} // end adjacent_difference()
+
+
+template <typename InputIterator, typename OutputIterator, typename BinaryFunction>
+OutputIterator adjacent_difference(InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::adjacent_difference(select_system(system1, system2), first, last, result, binary_op);
+} // end adjacent_difference()
+
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/advance.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/advance.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7b5f261bdced89967d51894e039e4a58ec05820b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/advance.inl
@@ -0,0 +1,74 @@
+/*
+ *  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>
+#include <thrust/advance.h>
+#include <thrust/system/detail/generic/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_difference_type, difference_type)
+
+template <typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n)
+{
+  thrust::system::detail::generic::advance(i, n);
+}
+
+template <typename InputIterator>
+__host__ __device__
+InputIterator next(
+  InputIterator i
+, typename iterator_traits<InputIterator>::difference_type n = 1
+)
+{
+  thrust::system::detail::generic::advance(i, n);
+  return i;
+}
+
+template <typename BidirectionalIterator>
+__host__ __device__
+BidirectionalIterator prev(
+  BidirectionalIterator i
+, typename iterator_traits<BidirectionalIterator>::difference_type n = 1
+)
+{
+  thrust::system::detail::generic::advance(i, -n);
+  return i;
+}
+
+template <typename BidirectionalIterator>
+__host__ __device__
+typename detail::disable_if<
+  has_difference_type<iterator_traits<BidirectionalIterator> >::value
+, BidirectionalIterator
+>::type prev(
+  BidirectionalIterator i
+, typename detail::pointer_traits<BidirectionalIterator>::difference_type n = 1
+)
+{
+  thrust::system::detail::generic::advance(i, -n);
+  return i;
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/algorithm_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/algorithm_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..c09b9a0a0b4dcc52924425d1549093668e5d2952
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/algorithm_wrapper.h
@@ -0,0 +1,27 @@
+/*
+ *  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
+
+// 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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/alignment.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/alignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..96fb8436a75286439e62fe5d99ce1a9b4c8b777e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/alignment.h
@@ -0,0 +1,204 @@
+/*
+ *  Copyright 2017 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 alignment.h
+ *  \brief Type-alignment utilities.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h> // For `integral_constant`.
+
+#include <cstddef> // For `std::size_t` and `std::max_align_t`.
+
+#if THRUST_CPP_DIALECT >= 2011
+    #include <type_traits> // For `std::alignment_of`. 
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+/// \p THRUST_ALIGNOF is a macro that takes a single type-id as a parameter,
+/// and returns the alignment requirement of the type in bytes.
+/// 
+/// It is an approximation of C++11's `alignof` operator.
+///
+/// Note: MSVC does not allow the builtin used to implement this to be placed
+/// inside of a `__declspec(align(#))` attribute. As a workaround, you can
+/// assign the result of \p THRUST_ALIGNOF to a variable and pass the variable
+/// as the argument to `__declspec(align(#))`.
+#if THRUST_CPP_DIALECT >= 2011
+    #define THRUST_ALIGNOF(x) alignof(x) 
+#else
+    #define THRUST_ALIGNOF(x) __alignof(x)
+#endif
+
+/// \p alignment_of provides the member constant `value` which is equal to the
+/// alignment requirement of the type `T`, as if obtained by a C++11 `alignof`
+/// expression.
+/// 
+/// It is an implementation of C++11's \p std::alignment_of.
+#if THRUST_CPP_DIALECT >= 2011
+    template <typename T>
+    using alignment_of = std::alignment_of<T>;
+#else
+    template <typename T>
+    struct alignment_of;
+
+    template <typename T, std::size_t size_diff>
+    struct alignment_of_helper
+    {
+        static const std::size_t value =
+            integral_constant<std::size_t, size_diff>::value;
+    };
+
+    template <typename T>
+    struct alignment_of_helper<T, 0>
+    {
+        static const std::size_t value = alignment_of<T>::value;
+    };
+
+    template <typename T>
+    struct alignment_of
+    {
+      private:
+        struct impl
+        {
+            T    x;
+            char c;
+        };
+
+      public:
+        static const std::size_t value =
+            alignment_of_helper<impl, sizeof(impl) - sizeof(T)>::value;
+    };
+#endif
+
+/// \p aligned_type provides the nested type `type`, which is a trivial
+/// type whose alignment requirement is a divisor of `Align`.
+///
+/// The behavior is undefined if `Align` is not a power of 2.
+template <std::size_t Align>
+struct aligned_type;
+
+#if THRUST_CPP_DIALECT >= 2011                                                     \
+  && (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                        \
+  && (THRUST_GCC_VERSION >= 40800)
+    // C++11 implementation, excluding GCC 4.7, which doesn't have `alignas`.
+    template <std::size_t Align>
+    struct aligned_type
+    {
+        struct alignas(Align) type {};
+    };
+#elif  (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)                    \
+    || (   (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                 \
+        && (THRUST_GCC_VERSION < 40600))
+    // C++03 implementation for MSVC and GCC <= 4.5.
+    // 
+    // We have to implement `aligned_type` with specializations for MSVC
+    // and GCC 4.2.x and older because they require literals as arguments to 
+    // their alignment attribute.
+
+    #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)
+        // MSVC implementation.
+        #define THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(X)                  \
+            template <>                                                       \
+            struct aligned_type<X>                                            \
+            {                                                                 \
+                __declspec(align(X)) struct type {};                          \
+            };                                                                \
+            /**/
+    #else
+        // GCC <= 4.2 implementation.
+        #define THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(X)                  \
+            template <>                                                       \
+            struct aligned_type<X>                                            \
+            {                                                                 \
+                struct type {} __attribute__((aligned(X)));                   \
+            };                                                                \
+            /**/
+    #endif
+    
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(1);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(2);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(4);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(8);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(16);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(32);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(64);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(128);
+
+    #undef THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION
+#else
+    // C++03 implementation for GCC > 4.5, Clang, PGI, ICPC, and xlC.
+    template <std::size_t Align>
+    struct aligned_type
+    {
+        struct type {} __attribute__((aligned(Align)));
+    };
+#endif
+
+/// \p max_align_t is a trivial type whose alignment requirement is at least as
+/// strict (as large) as that of every scalar type.
+///
+/// It is an implementation of C++11's \p std::max_align_t.
+#if THRUST_CPP_DIALECT >= 2011                                                     \
+  && (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                        \
+  && (THRUST_GCC_VERSION >= 40900)
+    // GCC 4.7 and 4.8 don't have `std::max_align_t`.
+    using max_align_t = std::max_align_t;
+#else
+    union max_align_t
+    {
+        // These cannot be private because C++03 POD types cannot have private
+        // data members.
+        char c;
+        short s;
+        int i;
+        long l;
+        float f;
+        double d;
+        long long ll;
+        long double ld;
+        void* p;
+    };
+#endif
+
+/// \p aligned_reinterpret_cast `reinterpret_cast`s \p u of type \p U to `void*`
+/// and then `reinterpret_cast`s the result to \p T. The indirection through
+/// `void*` suppresses compiler warnings when the alignment requirement of \p *u
+/// is less than the alignment requirement of \p *t. The caller of
+/// \p aligned_reinterpret_cast is responsible for ensuring that the alignment
+/// requirements are actually satisified.
+template <typename T, typename U>
+__host__ __device__
+T aligned_reinterpret_cast(U u)
+{
+  return reinterpret_cast<T>(reinterpret_cast<void*>(u));
+}
+
+__host__ __device__
+inline std::size_t aligned_storage_size(std::size_t n, std::size_t align)
+{
+  return ((n + align - 1) / align) * align;
+}
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a5af3661f39baa353f696aa63f67347262eece4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.h
@@ -0,0 +1,442 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits/has_member_function.h>
+#include <thrust/detail/type_traits.h>
+
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// forward declaration for has_member_system
+template<typename Alloc> struct allocator_system;
+
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_value_type, value_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_pointer, pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_pointer, const_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_reference, reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_reference, const_reference)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_void_pointer, void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_const_void_pointer, const_void_pointer)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_difference_type, difference_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_size_type, size_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_move_assignment, propagate_on_container_move_assignment)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_propagate_on_container_swap, propagate_on_container_swap)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_system_type, system_type)
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_is_always_equal, is_always_equal)
+__THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system)
+
+template<typename Alloc, typename U>
+  struct has_rebind
+{
+  typedef char yes_type;
+  typedef int  no_type;
+
+  template<typename S>
+  static yes_type test(typename S::template rebind<U>::other*);
+  template<typename S>
+  static no_type  test(...);
+
+  static bool const value = sizeof(test<U>(0)) == sizeof(yes_type);
+
+  typedef thrust::detail::integral_constant<bool, value> type;
+};
+
+// The following fields of std::allocator have been deprecated (since C++17).
+// There's no way to detect it other than explicit specialization.
+#if THRUST_CPP_DIALECT >= 2017
+#define THRUST_SPECIALIZE_DEPRECATED(trait_name)                               \
+template <typename T>                                                          \
+struct trait_name<std::allocator<T>> : false_type {};
+
+THRUST_SPECIALIZE_DEPRECATED(has_is_always_equal)
+THRUST_SPECIALIZE_DEPRECATED(has_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_const_pointer)
+THRUST_SPECIALIZE_DEPRECATED(has_reference)
+THRUST_SPECIALIZE_DEPRECATED(has_const_reference)
+
+#undef THRUST_SPECIALIZE_DEPRECATED
+
+template<typename T, typename U>
+struct has_rebind<std::allocator<T>, U> : false_type {};
+#endif
+
+template<typename T>
+  struct nested_pointer
+{
+  typedef typename T::pointer type;
+};
+
+template<typename T>
+  struct nested_const_pointer
+{
+  typedef typename T::const_pointer type;
+};
+
+template<typename T>
+  struct nested_reference
+{
+  typedef typename T::reference type;
+};
+
+template<typename T>
+  struct nested_const_reference
+{
+  typedef typename T::const_reference type;
+};
+
+template<typename T>
+  struct nested_void_pointer
+{
+  typedef typename T::void_pointer type;
+};
+
+template<typename T>
+  struct nested_const_void_pointer
+{
+  typedef typename T::const_void_pointer type;
+};
+
+template<typename T>
+  struct nested_difference_type
+{
+  typedef typename T::difference_type type;
+};
+
+template<typename T>
+  struct nested_size_type
+{
+  typedef typename T::size_type type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_copy_assignment
+{
+  typedef typename T::propagate_on_container_copy_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_move_assignment
+{
+  typedef typename T::propagate_on_container_move_assignment type;
+};
+
+template<typename T>
+  struct nested_propagate_on_container_swap
+{
+  typedef typename T::propagate_on_container_swap type;
+};
+
+template<typename T>
+  struct nested_is_always_equal
+{
+  typedef typename T::is_always_equal type;
+};
+
+template<typename T>
+  struct nested_system_type
+{
+  typedef typename T::system_type type;
+};
+
+template<typename Alloc>
+  struct has_member_system
+{
+  typedef typename allocator_system<Alloc>::type system_type;
+
+  typedef typename has_member_system_impl<Alloc, system_type&(void)>::type type;
+  static const bool value = type::value;
+};
+
+template<class Alloc, class U, bool = has_rebind<Alloc, U>::value>
+  struct rebind_alloc
+{
+    typedef typename Alloc::template rebind<U>::other type;
+};
+
+#if THRUST_CPP_DIALECT >= 2011
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, true>
+{
+    typedef typename Alloc<T, Args...>::template rebind<U>::other type;
+};
+
+template<template<typename, typename...> class Alloc,
+         typename T, typename... Args, typename U>
+  struct rebind_alloc<Alloc<T, Args...>, U, false>
+{
+    typedef Alloc<U, Args...> type;
+};
+#else // C++03
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, true>
+{
+    typedef typename Alloc<T>::template rebind<U>::other type;
+};
+
+template <template <typename> class Alloc, typename T, typename U>
+  struct rebind_alloc<Alloc<T>, U, false>
+{
+    typedef Alloc<U> type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, true>
+{
+    typedef typename Alloc<T, A0>::template rebind<U>::other type;
+};
+
+template<template<typename, typename> class Alloc,
+         typename T, typename A0, typename U>
+  struct rebind_alloc<Alloc<T, A0>, U, false>
+{
+    typedef Alloc<U, A0> type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, true>
+{
+    typedef typename Alloc<T, A0, A1>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1>, U, false>
+{
+    typedef Alloc<U, A0, A1> type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, true>
+{
+    typedef typename Alloc<T, A0, A1, A2>::template rebind<U>::other type;
+};
+
+template<template<typename, typename, typename, typename> class Alloc,
+         typename T, typename A0, typename A1, typename A2, typename U>
+  struct rebind_alloc<Alloc<T, A0, A1, A2>, U, false>
+{
+    typedef Alloc<U, A0, A1, A2> type;
+};
+#endif
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+  struct allocator_traits
+{
+  typedef Alloc allocator_type;
+
+  typedef typename allocator_type::value_type value_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_pointer<allocator_type>,
+    identity_<value_type*>
+  >::type pointer;
+
+  private:
+    template<typename T>
+      struct rebind_pointer
+    {
+      typedef typename pointer_traits<pointer>::template rebind<T>::other type;
+    };
+
+  public:
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_pointer<allocator_type>,
+    rebind_pointer<const value_type>
+  >::type const_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_void_pointer<allocator_type>,
+    rebind_pointer<void>
+  >::type void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_const_void_pointer<allocator_type>::value,
+    allocator_traits_detail::nested_const_void_pointer<allocator_type>,
+    rebind_pointer<const void>
+  >::type const_void_pointer;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_difference_type<allocator_type>::value,
+    allocator_traits_detail::nested_difference_type<allocator_type>,
+    pointer_difference<pointer>
+  >::type difference_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_size_type<allocator_type>::value,
+    allocator_traits_detail::nested_size_type<allocator_type>,
+    make_unsigned<difference_type>
+  >::type size_type;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_copy_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_copy_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_copy_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_move_assignment<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_move_assignment<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_move_assignment;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_propagate_on_container_swap<allocator_type>::value,
+    allocator_traits_detail::nested_propagate_on_container_swap<allocator_type>,
+    identity_<false_type>
+  >::type propagate_on_container_swap;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+    allocator_traits_detail::nested_is_always_equal<allocator_type>,
+    is_empty<allocator_type>
+  >::type is_always_equal;
+
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<allocator_type>::value,
+    allocator_traits_detail::nested_system_type<allocator_type>,
+    thrust::iterator_system<pointer>
+  >::type system_type;
+
+  // XXX rebind and rebind_traits are alias templates
+  //     and so are omitted while c++11 is unavailable
+
+#if THRUST_CPP_DIALECT >= 2011
+  template <typename U>
+  using rebind_alloc =
+    typename allocator_traits_detail::rebind_alloc<allocator_type, U>::type;
+
+  template <typename U>
+  using rebind_traits = allocator_traits<rebind_alloc<U>>;
+
+  // We define this nested type alias for compatibility with the C++03-style
+  // rebind_* mechanisms.
+  using other = allocator_traits;
+#else
+  template <typename U>
+  struct rebind_alloc
+  {
+    typedef typename
+      allocator_traits_detail::rebind_alloc<allocator_type, U>::type other;
+  };
+  template <typename U>
+  struct rebind_traits
+  {
+    typedef allocator_traits<typename rebind_alloc<U>::other> other;
+  };
+#endif
+
+  // Deprecated std::allocator typedefs that we need:
+  typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+  typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n);
+
+  inline __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint);
+
+  inline __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n);
+
+  // XXX should probably change T* to pointer below and then relax later
+
+  template<typename T>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p);
+  
+  template<typename T, typename Arg1>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, const Arg1 &arg1);
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename... Args>
+  inline __host__ __device__ static void construct(allocator_type &a, T *p, Args&&... args);
+#endif
+
+  template<typename T>
+  inline __host__ __device__ static void destroy(allocator_type &a, T *p);
+
+  inline __host__ __device__
+  static size_type max_size(const allocator_type &a);
+}; // end allocator_traits
+
+
+// we consider a type an allocator if T::value_type exists
+// it doesn't make much sense (containers, which are not allocators, will fulfill this requirement),
+// but allocator_traits is specified to work for any type with that nested typedef
+template<typename T>
+  struct is_allocator
+    : allocator_traits_detail::has_value_type<T>
+{};
+
+
+// XXX consider moving this non-standard functionality inside allocator_traits
+template<typename Alloc>
+  struct allocator_system
+{
+  // the type of the allocator's system
+  typedef typename eval_if<
+    allocator_traits_detail::has_system_type<Alloc>::value,
+    allocator_traits_detail::nested_system_type<Alloc>,
+    thrust::iterator_system<
+      typename allocator_traits<Alloc>::pointer
+    >
+  >::type type;
+
+  // the type that get returns
+  typedef typename eval_if<
+    allocator_traits_detail::has_member_system<Alloc>::value, // if Alloc.system() exists
+    add_reference<type>,                                      // then get() needs to return a reference
+    identity_<type>                                           // else get() needs to return a value
+  >::type get_result_type;
+
+  __host__ __device__
+  inline static get_result_type get(Alloc &a);
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/allocator_traits.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2753300949497068668c40f6f56b4e74aceb2e9e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/allocator_traits.inl
@@ -0,0 +1,465 @@
+/*
+ *  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>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/is_call_possible.h>
+#include <thrust/detail/integer_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <thrust/detail/type_deduction.h>
+#endif
+
+#include <thrust/detail/memory_wrapper.h>
+#include <new>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+#if THRUST_CPP_DIALECT >= 2011
+
+// std::allocator's member functions are deprecated in C++17 and removed in
+// C++20, so we can't just use the generic implementation for allocator_traits
+// that calls the allocator's member functions.
+// Instead, specialize allocator_traits for std::allocator and defer to
+// std::allocator_traits<std::allocator> and let the STL do whatever it needs
+// to for the current c++ version. Manually forward the calls to suppress
+// host/device warnings.
+template <typename T>
+struct allocator_traits<std::allocator<T>>
+  : public std::allocator_traits<std::allocator<T>>
+{
+private:
+  using superclass = std::allocator_traits<std::allocator<T>>;
+
+public:
+  using allocator_type = typename superclass::allocator_type;
+  using value_type = typename superclass::value_type;
+  using pointer = typename superclass::pointer;
+  using const_pointer = typename superclass::const_pointer;
+  using void_pointer = typename superclass::void_pointer;
+  using const_void_pointer = typename superclass::const_void_pointer;
+  using difference_type = typename superclass::difference_type;
+  using size_type = typename superclass::size_type;
+  using propagate_on_container_swap = typename superclass::propagate_on_container_swap;
+  using propagate_on_container_copy_assignment =
+    typename superclass::propagate_on_container_copy_assignment;
+  using propagate_on_container_move_assignment =
+    typename superclass::propagate_on_container_move_assignment;
+
+  // std::allocator_traits added this in C++17, but thrust::allocator_traits defines
+  // it unconditionally.
+  using is_always_equal = typename eval_if<
+      allocator_traits_detail::has_is_always_equal<allocator_type>::value,
+      allocator_traits_detail::nested_is_always_equal<allocator_type>,
+      is_empty<allocator_type>
+    >::type;
+
+  // std::allocator_traits doesn't provide these, but
+  // thrust::detail::allocator_traits does. These used to be part of the
+  // std::allocator API but were deprecated in C++17.
+  using reference = typename thrust::detail::pointer_traits<pointer>::reference;
+  using const_reference = typename thrust::detail::pointer_traits<const_pointer>::reference;
+
+  template <typename U>
+  using rebind_alloc = std::allocator<U>;
+  template <typename U>
+  using rebind_traits = allocator_traits<std::allocator<U>>;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n)
+  {
+    return superclass::allocate(a, n);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static pointer allocate(allocator_type &a, size_type n, const_void_pointer hint)
+  {
+    return superclass::allocate(a, n, hint);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static void deallocate(allocator_type &a, pointer p, size_type n)
+  {
+    superclass::deallocate(a, p, n);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U, typename ...Args>
+  __host__ __device__
+  static void construct(allocator_type &a, U *p, Args&&... args)
+  {
+    superclass::construct(a, p, THRUST_FWD(args)...);
+  }
+
+  __thrust_exec_check_disable__
+  template <typename U>
+  __host__ __device__
+  static void destroy(allocator_type &a, U *p)
+  {
+    superclass::destroy(a, p);
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  static size_type max_size(const allocator_type &a)
+  {
+    return superclass::max_size(a);
+  }
+};
+
+#endif //  C++11
+
+namespace allocator_traits_detail
+{
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate)
+
+template<typename Alloc>
+  class has_member_allocate_with_hint
+{
+  typedef typename allocator_traits<Alloc>::pointer            pointer;
+  typedef typename allocator_traits<Alloc>::size_type          size_type;
+  typedef typename allocator_traits<Alloc>::const_void_pointer const_void_pointer;
+
+  public:
+    typedef typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type,const_void_pointer)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return a.allocate(n,hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_allocate_with_hint<Alloc>::value,
+    typename allocator_traits<Alloc>::pointer
+  >::type
+    allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer)
+{
+  return a.allocate(n);
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct)
+
+template<typename Alloc, typename T>
+  struct has_member_construct1
+    : has_member_construct1_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &a, T *p)
+{
+  a.construct(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct1<Alloc,T>::value
+    >::type
+      construct(Alloc &, T *p)
+{
+  ::new(static_cast<void*>(p)) T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct)
+
+template<typename Alloc, typename T, typename Arg1>
+  struct has_member_construct2
+    : has_member_construct2_impl<Alloc, void(T*,const Arg1 &)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &a, T *p, const Arg1 &arg1)
+{
+  a.construct(p,arg1);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename Arg1>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_construct2<Alloc,T,Arg1>::value
+    >::type
+      construct(Alloc &, T *p, const Arg1 &arg1)
+{
+  ::new(static_cast<void*>(p)) T(arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_constructN_impl, construct)
+
+template<typename Alloc, typename T, typename... Args>
+  struct has_member_constructN
+    : has_member_constructN_impl<Alloc, void(T*, Args...)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &a, T* p, Args&&... args)
+{
+  a.construct(p, THRUST_FWD(args)...);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T, typename... Args>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_constructN<Alloc, T, Args...>::value
+    >::type
+      construct(Alloc &, T* p, Args&&... args)
+{
+  ::new(static_cast<void*>(p)) T(THRUST_FWD(args)...);
+}
+
+#endif
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy)
+
+template<typename Alloc, typename T>
+  struct has_member_destroy
+    : has_member_destroy_impl<Alloc, void(T*)>
+{};
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename enable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &a, T *p)
+{
+  a.destroy(p);
+}
+
+__thrust_exec_check_disable__
+template<typename Alloc, typename T>
+  inline __host__ __device__
+    typename disable_if<
+      has_member_destroy<Alloc,T>::value
+    >::type
+      destroy(Alloc &, T *p)
+{
+  p->~T();
+}
+
+
+__THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size)
+
+template<typename Alloc>
+  class has_member_max_size
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+
+  public:
+    typedef typename has_member_max_size_impl<Alloc, size_type(void)>::type type;
+    static const bool value = type::value;
+};
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &a)
+{
+  return a.max_size();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_max_size<Alloc>::value,
+    typename allocator_traits<Alloc>::size_type
+  >::type
+    max_size(const Alloc &)
+{
+  typedef typename allocator_traits<Alloc>::size_type size_type;
+  return thrust::detail::integer_traits<size_type>::const_max;
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename enable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type &
+  >::type
+    system(Alloc &a)
+{
+  // return the allocator's system
+  return a.system();
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename disable_if<
+    has_member_system<Alloc>::value,
+    typename allocator_system<Alloc>::type
+  >::type
+    system(Alloc &)
+{
+  // return a copy of a value-initialized system
+  return typename allocator_system<Alloc>::type();
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    typename allocator_traits<Alloc>::pointer
+      allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.allocate(n);
+    }
+  };
+
+  return workaround_warnings::allocate(a, n);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::pointer
+    allocator_traits<Alloc>
+      ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint)
+{
+  return allocator_traits_detail::allocate(a, n, hint);
+}
+
+template<typename Alloc>
+__host__ __device__
+  void allocator_traits<Alloc>
+    ::deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+{
+  struct workaround_warnings
+  {
+    __thrust_exec_check_disable__
+    static __host__ __device__
+    void deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n)
+    {
+      return a.deallocate(p,n);
+    }
+  };
+
+  return workaround_warnings::deallocate(a,p,n);
+}
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::construct(a,p);
+}
+
+template<typename Alloc>
+  template<typename T, typename Arg1>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, const Arg1 &arg1)
+{
+  return allocator_traits_detail::construct(a,p,arg1);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename Alloc>
+  template<typename T, typename... Args>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::construct(allocator_type &a, T *p, Args&&... args)
+{
+  return allocator_traits_detail::construct(a, p, THRUST_FWD(args)...);
+}
+
+#endif
+
+template<typename Alloc>
+  template<typename T>
+  __host__ __device__
+    void allocator_traits<Alloc>
+      ::destroy(allocator_type &a, T *p)
+{
+  return allocator_traits_detail::destroy(a,p);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_traits<Alloc>::size_type
+    allocator_traits<Alloc>
+      ::max_size(const allocator_type &a)
+{
+  return allocator_traits_detail::max_size(a);
+}
+
+template<typename Alloc>
+__host__ __device__
+  typename allocator_system<Alloc>::get_result_type
+    allocator_system<Alloc>
+      ::get(Alloc &a)
+{
+  return allocator_traits_detail::system(a);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3c2de32462772de3ecbeaee71ed37d57f3dc135
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.h
@@ -0,0 +1,46 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result);
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..a71cca1f7207278d6e3d9116ce48ce791e0fe98c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/copy_construct_range.inl
@@ -0,0 +1,310 @@
+/*
+ *  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>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/tuple.h>
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator, typename InputType, typename OutputType>
+  struct copy_construct_with_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  copy_construct_with_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename Tuple>
+  inline __host__ __device__
+  void operator()(Tuple t)
+  {
+    const InputType &in = thrust::get<0>(t);
+    OutputType &out = thrust::get<1>(t);
+
+    allocator_traits<Allocator>::construct(a, &out, in);
+  }
+};
+
+
+// we need to use allocator_traits<Allocator>::construct() to
+// copy construct a T if either:
+// 1. Allocator has a 2-argument construct() member or
+// 2. T has a non-trivial copy constructor
+template<typename Allocator, typename T>
+  struct needs_copy_construct_via_allocator
+    : integral_constant<
+        bool,
+        (has_member_construct2<Allocator,T,T>::value || !has_trivial_copy_constructor<T>::value)
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// copy constructor, so we needn't consider or use its construct() member for copy construction
+template<typename U, typename T>
+  struct needs_copy_construct_via_allocator<std::allocator<U>, T>
+    : integral_constant<
+        bool,
+        !has_trivial_copy_constructor<T>::value
+      >
+{};
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy
+//     perhaps generic::uninitialized_copy could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &a,
+                                      const thrust::execution_policy<FromSystem> &,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+  ZipIterator end = begin;
+
+  // get a zip_iterator pointing to the end
+  const typename thrust::iterator_difference<InputIterator>::type n = thrust::distance(first,last);
+  thrust::advance(end,n);
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each
+  // note we use to_system to dispatch the for_each
+  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy_n
+//     perhaps generic::uninitialized_copy_n could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &a,
+                                        const thrust::execution_policy<FromSystem> &,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each_n
+  // note we use to_system to dispatch the for_each_n
+  ZipIterator end = thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &,
+                                      const thrust::execution_policy<FromSystem> &from_system,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy and hope for the best
+  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
+} // end uninitialized_copy_with_allocator()
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &,
+                                        const thrust::execution_policy<FromSystem> &from_system,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy_n and hope for the best
+  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
+} // end uninitialized_copy_with_allocator_n()
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  // just call two_system_copy
+  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  // just call two_system_copy_n
+  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
+}
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b5026c05b342b0473b2c6aaee6c79e8845ccc5a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.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
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+inline void default_construct_range(Allocator &a, Pointer p, Size n);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/default_construct_range.inl>
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..6d26578fa230a8bcce91cc3400c3ef547163fd2a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/default_construct_range.inl
@@ -0,0 +1,112 @@
+/*
+ *  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>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator>
+  struct construct1_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  construct1_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::construct(a, &x);
+  }
+};
+
+
+// we need to construct T via the allocator if...
+template<typename Allocator, typename T>
+  struct needs_default_construct_via_allocator
+    : thrust::detail::or_<
+        has_member_construct1<Allocator,T>,               // if the Allocator does something interesting
+        thrust::detail::not_<has_trivial_constructor<T> > // or if T's default constructor does something interesting
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// default constructor, so we needn't use it for default construction
+// unless T's constructor does something interesting
+template<typename U, typename T>
+  struct needs_default_construct_via_allocator<std::allocator<U>, T>
+    : thrust::detail::not_<has_trivial_constructor<T> >
+{};
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, construct1_via_allocator<Allocator>(a));
+}
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename disable_if<
+    needs_default_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value
+  >::type
+    default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, typename pointer_element<Pointer>::type());
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void default_construct_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::default_construct_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfc7e3f6ef519f182a2fcb11f8b0b3a1a8612a7e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.h
@@ -0,0 +1,33 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  inline void destroy_range(Allocator &a, Pointer p, Size n);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/destroy_range.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..662177f3a72f7ce97bdd8ce49ae637d2a096ee7f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/destroy_range.inl
@@ -0,0 +1,167 @@
+/*
+ *  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>
+
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+// destroy_range has three cases:
+// if Allocator has an effectful member function destroy:
+//   1. destroy via the allocator
+// else
+//   2. if T has a non-trivial destructor, destroy the range without using the allocator
+//   3. if T has a trivial destructor, do a no-op
+
+template<typename Allocator, typename T>
+  struct has_effectful_member_destroy
+    : has_member_destroy<Allocator,T>
+{};
+
+// std::allocator::destroy's only effect is to invoke its argument's destructor
+template<typename U, typename T>
+  struct has_effectful_member_destroy<std::allocator<U>, T>
+    : thrust::detail::false_type
+{};
+
+// case 1: Allocator has an effectful 1-argument member function "destroy"
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case1
+    : thrust::detail::enable_if<
+        has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case2
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        !has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 3: Allocator has no member function "destroy", and T has a trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case3
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+
+
+template<typename Allocator>
+  struct destroy_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  destroy_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+
+// destroy_range case 1: destroy via allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case1<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+
+// we must prepare for His coming
+struct gozer
+{
+  __thrust_exec_check_disable__
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case2<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
+}
+
+
+// destroy_range case 3: no-op
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case3<Allocator,Pointer>::type
+    destroy_range(Allocator &, Pointer, Size)
+{
+  // no op
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void destroy_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::destroy_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7572cb2d2bc1c2e509dcb80911c60aacbbce6e4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.h
@@ -0,0 +1,35 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size, typename T>
+__host__ __device__
+inline void fill_construct_range(Allocator &a, Pointer p, Size n, const T &value);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/fill_construct_range.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.inl
new file mode 100644
index 0000000000000000000000000000000000000000..876b5ddd26476fb1d8734941900a3977f24c0b1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/fill_construct_range.inl
@@ -0,0 +1,114 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/uninitialized_fill.h>
+#include <thrust/detail/memory_wrapper.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;
+
+  __host__ __device__
+  construct2_via_allocator(Allocator &a, const Arg1 &arg)
+    : a(a), arg(arg)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::construct(a, &x, arg);
+  }
+};
+
+
+template<typename Allocator, typename Pointer, typename Size, typename T>
+__host__ __device__
+  typename enable_if<
+    has_effectful_member_construct2<
+      Allocator,
+      typename pointer_element<Pointer>::type,
+      T
+    >::value
+  >::type
+    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>
+__host__ __device__
+  typename disable_if<
+    has_effectful_member_construct2<
+      Allocator,
+      typename pointer_element<Pointer>::type,
+      T
+    >::value
+  >::type
+    fill_construct_range(Allocator &a, Pointer p, Size n, const T &value)
+{
+  thrust::uninitialized_fill_n(allocator_system<Allocator>::get(a), p, n, value);
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Alloc, typename Pointer, typename Size, typename T>
+__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);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..af3d0fccbd740dafc8a04ae8102be5d1054874b7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.h
@@ -0,0 +1,51 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/allocator/tagged_allocator.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:
+    typedef thrust::detail::tagged_allocator<
+      T, System, Pointer
+    > super_t;
+
+  public:
+    typedef typename super_t::pointer   pointer;
+    typedef typename super_t::size_type size_type;
+
+    pointer allocate(size_type cnt);
+
+    void deallocate(pointer p, size_type n);
+};
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/malloc_allocator.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..d03d33305cb379d4007f1caa1cdebffcc77d5537
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/malloc_allocator.inl
@@ -0,0 +1,65 @@
+/*
+ *  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>
+#include <thrust/detail/allocator/malloc_allocator.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/bad_alloc.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/malloc_and_free.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)
+{
+  using thrust::system::detail::generic::select_system;
+
+  System system;
+  thrust::free(select_system(system), p);
+} // end malloc_allocator
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/no_throw_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/no_throw_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6c16985b11bb53c253fc9aa998cff5ad806ee43
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/no_throw_allocator.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>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BaseAllocator>
+  struct no_throw_allocator : BaseAllocator
+{
+  private:
+    typedef BaseAllocator super_t;
+  
+  public:
+    inline __host__ __device__
+    no_throw_allocator(const BaseAllocator &other = BaseAllocator())
+      : super_t(other)
+    {}
+
+    template<typename U>
+      struct rebind
+    {
+      typedef no_throw_allocator<typename super_t::template rebind<U>::other> other;
+    }; // end rebind
+
+    __host__ __device__
+    void deallocate(typename super_t::pointer p, typename super_t::size_type n)
+    {
+      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 __host__ __device__
+    bool operator==(no_throw_allocator const &other) { return super_t::operator==(other); }
+
+    inline __host__ __device__
+    bool operator!=(no_throw_allocator const &other) { return super_t::operator!=(other); }
+}; // end no_throw_allocator
+
+} // end detail
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..804c4e42e511c8d3ed7021cc99aeb3f0de778533
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.h
@@ -0,0 +1,100 @@
+/*
+ *  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>
+#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:
+    typedef void                                                                                 value_type;
+    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<void>::other       pointer;
+    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<const void>::other const_pointer;
+    typedef std::size_t                                                                          size_type;
+    typedef typename thrust::detail::pointer_traits<Pointer>::difference_type                    difference_type;
+    typedef Tag                                                                                  system_type;
+
+    template<typename U>
+      struct rebind
+    {
+      typedef tagged_allocator<U,Tag,Pointer> other;
+    }; // end rebind
+};
+
+template<typename T, typename Tag, typename Pointer>
+  class tagged_allocator
+{
+  public:
+    typedef T                                                                                 value_type;
+    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<T>::other       pointer;
+    typedef typename thrust::detail::pointer_traits<Pointer>::template rebind<const T>::other const_pointer;
+    typedef typename thrust::iterator_reference<pointer>::type                                reference;
+    typedef typename thrust::iterator_reference<const_pointer>::type                          const_reference;
+    typedef std::size_t                                                                       size_type;
+    typedef typename thrust::detail::pointer_traits<pointer>::difference_type                 difference_type;
+    typedef Tag                                                                               system_type;
+
+    template<typename U>
+      struct rebind
+    {
+      typedef tagged_allocator<U,Tag,Pointer> other;
+    }; // end rebind
+
+    __host__ __device__
+    inline tagged_allocator();
+
+    __host__ __device__
+    inline tagged_allocator(const tagged_allocator &);
+
+    template<typename U, typename OtherPointer>
+    __host__ __device__
+    inline tagged_allocator(const tagged_allocator<U, Tag, OtherPointer> &);
+
+    __host__ __device__
+    inline ~tagged_allocator();
+
+    __host__ __device__
+    pointer address(reference x) const;
+
+    __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>
+__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>
+__host__ __device__
+bool operator!=(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/tagged_allocator.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..bcd534cbceebb310f5acd7fd469f395c64deba3c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/tagged_allocator.inl
@@ -0,0 +1,104 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/allocator/tagged_allocator.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  tagged_allocator<T,Tag,Pointer>
+    ::tagged_allocator()
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __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>
+    __host__ __device__
+    tagged_allocator<T,Tag,Pointer>
+      ::tagged_allocator(const tagged_allocator<U,Tag,OtherPointer> &)
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  tagged_allocator<T,Tag,Pointer>
+    ::~tagged_allocator()
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __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>
+  __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>
+__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>
+__host__ __device__
+bool operator!=(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &)
+{
+  return false;
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8ef606258a0d802b792c72d9d896bcdd0eb8189
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.h
@@ -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>
+#include <thrust/detail/allocator/tagged_allocator.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/pair.h>
+#include <thrust/memory.h>
+#include <thrust/detail/execution_policy.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:
+    typedef thrust::detail::tagged_allocator<
+      T, System, thrust::pointer<T,System>
+    > super_t;
+
+    System &m_system;
+
+  public:
+    typedef typename super_t::pointer   pointer;
+    typedef typename super_t::size_type size_type;
+
+    inline __host__ __device__
+    temporary_allocator(const temporary_allocator &other) :
+      super_t(),
+      m_system(other.m_system)
+    {}
+
+    inline __host__ __device__
+    explicit temporary_allocator(thrust::execution_policy<System> &system) :
+      super_t(),
+      m_system(thrust::detail::derived_cast(system))
+    {}
+
+    __host__ __device__
+    pointer allocate(size_type cnt);
+
+    __host__ __device__
+    void deallocate(pointer p, size_type n);
+
+    __host__ __device__
+    inline System &system()
+    {
+      return m_system;
+    } // end system()
+
+  private:
+    typedef thrust::pair<pointer, size_type> pointer_and_size;
+}; // end temporary_allocator
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/temporary_allocator.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ef5d1afa503b9e2b8adcfa20cb6f6389c349e6fb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator/temporary_allocator.inl
@@ -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>
+#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>
+__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>
+__host__ __device__
+  void temporary_allocator<T,System>
+    ::deallocate(typename temporary_allocator<T,System>::pointer p, typename temporary_allocator<T,System>::size_type n)
+{
+  return thrust::return_temporary_buffer(system(), p, n);
+} // end temporary_allocator
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator_aware_execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator_aware_execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..eea93c035eab67ba8c1848c8c693b5b6b2f79c84
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/allocator_aware_execution_policy.h
@@ -0,0 +1,101 @@
+/*
+ *  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>
+#include <thrust/detail/execute_with_allocator_fwd.h>
+#include <thrust/detail/alignment.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <type_traits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace mr
+{
+
+template<typename T, class MR>
+class allocator;
+
+}
+
+namespace detail
+{
+
+template<template <typename> class ExecutionPolicyCRTPBase>
+struct allocator_aware_execution_policy
+{
+  template<typename MemoryResource>
+  struct execute_with_memory_resource_type
+  {
+    typedef thrust::detail::execute_with_allocator<
+      thrust::mr::allocator<
+        thrust::detail::max_align_t,
+        MemoryResource
+      >,
+      ExecutionPolicyCRTPBase
+    > type;
+  };
+
+  template<typename Allocator>
+  struct execute_with_allocator_type
+  {
+      typedef thrust::detail::execute_with_allocator<
+        Allocator,
+        ExecutionPolicyCRTPBase
+      > type;
+  };
+
+  template<typename MemoryResource>
+    typename execute_with_memory_resource_type<MemoryResource>::type
+      operator()(MemoryResource * mem_res) const
+  {
+    return typename execute_with_memory_resource_type<MemoryResource>::type(mem_res);
+  }
+
+  template<typename Allocator>
+    typename execute_with_allocator_type<Allocator&>::type
+      operator()(Allocator &alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator&>::type(alloc);
+  }
+
+  template<typename Allocator>
+    typename execute_with_allocator_type<Allocator>::type
+      operator()(const Allocator &alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator>::type(alloc);
+  }
+
+#if THRUST_CPP_DIALECT >= 2011
+  // just the rvalue overload
+  // perfect forwarding doesn't help, because a const reference has to be turned
+  // into a value by copying for the purpose of storing it in execute_with_allocator
+  template<typename Allocator,
+      typename std::enable_if<!std::is_lvalue_reference<Allocator>::value>::type * = nullptr>
+    typename execute_with_allocator_type<Allocator>::type
+      operator()(Allocator &&alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator>::type(std::move(alloc));
+  }
+#endif
+};
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/binary_search.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/binary_search.inl
new file mode 100644
index 0000000000000000000000000000000000000000..90350ced4bb3bed85d3a9cfa0911264ff7438415
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/binary_search.inl
@@ -0,0 +1,480 @@
+/*
+ *  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>
+#include <thrust/binary_search.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/binary_search.h>
+#include <thrust/system/detail/adl/binary_search.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first,
+                   ForwardIterator last,
+                   const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value,
+                   StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::equal_range;
+    return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::equal_range;
+    return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output,
+                             StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+//////////////////////
+// Scalar Functions //
+//////////////////////
+
+template <typename ForwardIterator, typename LessThanComparable>
+ForwardIterator lower_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::lower_bound(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+ForwardIterator lower_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::lower_bound(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+ForwardIterator upper_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::upper_bound(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+ForwardIterator upper_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::upper_bound(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+bool binary_search(ForwardIterator first,
+                   ForwardIterator last,
+                   const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::binary_search(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+bool binary_search(ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value,
+                   StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::binary_search(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::equal_range(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::equal_range(select_system(system), first, last, value, comp);
+}
+
+//////////////////////
+// Vector Functions //
+//////////////////////
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator lower_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator lower_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator upper_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator upper_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator binary_search(ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator binary_search(ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output,
+                             StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/caching_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/caching_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..941f52755ca6d1aa5333f85e2e702943693fd988
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/caching_allocator.h
@@ -0,0 +1,47 @@
+/*
+ *  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>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/disjoint_tls_pool.h>
+#include <thrust/mr/new.h>
+#include <thrust/mr/device_memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+inline
+thrust::mr::allocator<
+    char,
+    thrust::mr::disjoint_unsynchronized_pool_resource<
+        thrust::device_memory_resource,
+        thrust::mr::new_delete_resource
+    >
+> single_device_tls_caching_allocator()
+{
+    return {
+        &thrust::mr::tls_disjoint_pool(
+            thrust::mr::get_global_resource<thrust::device_memory_resource>(),
+            thrust::mr::get_global_resource<thrust::mr::new_delete_resource>()
+        )
+    };
+}
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/arithmetic.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/arithmetic.h
new file mode 100644
index 0000000000000000000000000000000000000000..518f184503c65c8ee82e0beeba88d9a1943fabc3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/arithmetic.h
@@ -0,0 +1,303 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/c99math.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+
+  /* --- Binary Arithmetic Operators --- */
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const complex<T0>& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() + y.real(), x.imag() + y.imag());
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const complex<T0>& x, const T1& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() + y, x.imag());
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator+(const T0& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x + y.real(), y.imag());
+}
+
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const complex<T0>& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() - y.real(), x.imag() - y.imag());
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const complex<T0>& x, const T1& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() - y, x.imag());
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator-(const T0& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x - y.real(), -y.imag());
+}
+
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const complex<T0>& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>( x.real() * y.real() - x.imag() * y.imag()
+			             , x.real() * y.imag() + x.imag() * y.real());
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const complex<T0>& x, const T1& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() * y, x.imag() * y);
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator*(const T0& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x * y.real(), x * y.imag());
+}
+
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const complex<T0>& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+
+  // Find `abs` by ADL.
+  using std::abs;
+
+  T s = abs(y.real()) + abs(y.imag());
+
+  T oos = T(1.0) / s;
+
+  T ars = x.real() * oos;
+  T ais = x.imag() * oos;
+  T brs = y.real() * oos;
+  T bis = y.imag() * oos;
+
+  s = (brs * brs) + (bis * bis);
+
+  oos = T(1.0) / s;
+
+  complex<T> quot( ((ars * brs) + (ais * bis)) * oos
+                 , ((ais * brs) - (ars * bis)) * oos);
+  return quot;
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const complex<T0>& x, const T1& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x.real() / y, x.imag() / y);
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+operator/(const T0& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return complex<T>(x) / y;
+}
+
+
+
+/* --- Unary Arithmetic Operators --- */
+
+template <typename T>
+__host__ __device__
+complex<T> operator+(const complex<T>& y)
+{
+  return y;
+}
+
+template <typename T>
+__host__ __device__
+complex<T> operator-(const complex<T>& y)
+{
+  return y * -T(1);
+}
+
+
+/* --- Other Basic Arithmetic Functions --- */
+
+// As std::hypot is only C++11 we have to use the C interface
+template <typename T>
+__host__ __device__
+T abs(const complex<T>& z)
+{
+  return hypot(z.real(), z.imag());
+}
+
+// XXX Why are we specializing here?
+namespace detail {
+namespace complex {
+
+__host__ __device__
+inline float abs(const thrust::complex<float>& z)
+{
+  return hypotf(z.real(),z.imag());
+}
+
+__host__ __device__
+inline double abs(const thrust::complex<double>& z)
+{
+  return hypot(z.real(),z.imag());
+}
+
+} // end namespace complex
+} // end namespace detail
+
+template <>
+__host__ __device__
+inline float abs(const complex<float>& z)
+{
+  return detail::complex::abs(z);
+}
+
+template <>
+__host__ __device__
+inline double abs(const complex<double>& z)
+{
+  return detail::complex::abs(z);
+}
+
+
+template <typename T>
+__host__ __device__
+T arg(const complex<T>& z)
+{
+  // Find `atan2` by ADL.
+  using std::atan2;
+  return atan2(z.imag(), z.real());
+}
+
+
+template <typename T>
+__host__ __device__
+complex<T> conj(const complex<T>& z)
+{
+  return complex<T>(z.real(), -z.imag());
+}
+
+
+template <typename T>
+__host__ __device__
+T norm(const complex<T>& z)
+{
+  return z.real() * z.real() + z.imag() * z.imag();
+}
+
+// XXX Why specialize these, we could just rely on ADL.
+template <>
+__host__ __device__
+inline float norm(const complex<float>& z)
+{
+  // Find `abs` and `sqrt` by ADL.
+  using std::abs;
+  using std::sqrt;
+
+  if (abs(z.real()) < sqrt(FLT_MIN) && abs(z.imag()) < sqrt(FLT_MIN))
+  {
+    float a = z.real() * 4.0f;
+    float b = z.imag() * 4.0f;
+    return (a * a + b * b) / 16.0f;
+  }
+
+  return z.real() * z.real() + z.imag() * z.imag();
+}
+
+template <>
+__host__ __device__
+inline double norm(const complex<double>& z)
+{
+  // Find `abs` and `sqrt` by ADL.
+  using std::abs;
+  using std::sqrt;
+
+  if (abs(z.real()) < sqrt(DBL_MIN) && abs(z.imag()) < sqrt(DBL_MIN))
+  {
+    double a = z.real() * 4.0;
+    double b = z.imag() * 4.0;
+    return (a * a + b * b) / 16.0;
+  }
+
+  return z.real() * z.real() + z.imag() * z.imag();
+}
+
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+polar(const T0& m, const T1& theta)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+
+  // Find `cos` and `sin` by ADL.
+  using std::cos;
+  using std::sin;
+
+  return complex<T>(m * cos(theta), m * sin(theta));
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/c99math.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/c99math.h
new file mode 100644
index 0000000000000000000000000000000000000000..e735b850c73b924a1491d871d542ed4b9aaa94ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/c99math.h
@@ -0,0 +1,197 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <math.h>
+#include <cmath>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace complex
+{
+
+// Define basic arithmetic functions so we can use them without explicit scope
+// keeping the code as close as possible to FreeBSDs for ease of maintenance.
+// It also provides an easy way to support compilers with missing C99 functions.
+// When possible, just use the names in the global scope.
+// Some platforms define these as macros, others as free functions.
+// Avoid using the std:: form of these as nvcc may treat std::foo() as __host__ functions.
+
+using ::log;
+using ::acos;
+using ::asin;
+using ::sqrt;
+using ::sinh;
+using ::tan;
+using ::cos;
+using ::sin;
+using ::exp;
+using ::cosh;
+using ::atan;
+
+template <typename T>
+inline __host__ __device__ T infinity();
+
+template <>
+inline __host__ __device__ float infinity<float>()
+{
+  float res;
+  set_float_word(res, 0x7f800000);
+  return res;
+}
+
+
+template <>
+inline __host__ __device__ double infinity<double>()
+{
+  double res;
+  insert_words(res, 0x7ff00000,0);
+  return res;
+}
+
+#if defined _MSC_VER
+__host__ __device__ inline int isinf(float x){
+  return std::abs(x) == infinity<float>();
+}
+
+__host__ __device__ inline int isinf(double x){
+  return std::abs(x) == infinity<double>();
+}
+
+__host__ __device__ inline int isnan(float x){
+  return x != x;
+}
+
+__host__ __device__ inline int isnan(double x){
+  return x != x;
+}
+
+__host__ __device__ inline int signbit(float x){
+  return ((*((uint32_t *)&x)) & 0x80000000) != 0 ? 1 : 0;
+}
+
+__host__ __device__ inline int signbit(double x){
+  return ((*((uint64_t *)&x)) & 0x8000000000000000) != 0ull ? 1 : 0;
+}
+
+__host__ __device__ inline int isfinite(float x){
+  return !isnan(x) && !isinf(x);
+}
+
+__host__ __device__ inline int isfinite(double x){
+  return !isnan(x) && !isinf(x);
+}
+
+#else
+
+#  if defined(__CUDACC__) && !(defined(__CUDA__) && defined(__clang__)) && !defined(_NVHPC_CUDA)
+// NVCC implements at least some signature of these as functions not macros.
+using ::isinf;
+using ::isnan;
+using ::signbit;
+using ::isfinite;
+#  else
+// Some compilers do not provide these in the global scope, because they are
+// supposed to be macros. The versions in `std` are supposed to be functions.
+// Since we're not compiling with nvcc, it's safe to use the functions in std::
+using std::isinf;
+using std::isnan;
+using std::signbit;
+using std::isfinite;
+#  endif // __CUDACC__
+#endif // _MSC_VER
+
+using ::atanh;
+
+#if defined _MSC_VER
+
+__host__ __device__ inline double copysign(double x, double y){
+  uint32_t hx,hy;
+  get_high_word(hx,x);
+  get_high_word(hy,y);
+  set_high_word(x,(hx&0x7fffffff)|(hy&0x80000000));
+  return x;
+}
+
+__host__ __device__ inline float copysignf(float x, float y){
+  uint32_t ix,iy;
+  get_float_word(ix,x);
+  get_float_word(iy,y);
+  set_float_word(x,(ix&0x7fffffff)|(iy&0x80000000));
+  return x;
+}
+
+
+
+#if !defined(__CUDACC__) && !defined(_NVHPC_CUDA)
+
+// Simple approximation to log1p as Visual Studio is lacking one
+inline double log1p(double x){
+  double u = 1.0+x;
+  if(u == 1.0){
+    return x;
+  }else{
+    if(u > 2.0){
+      // Use normal log for large arguments
+      return log(u);
+    }else{
+      return log(u)*(x/(u-1.0));
+    }
+  }
+}
+
+inline float log1pf(float x){
+  float u = 1.0f+x;
+  if(u == 1.0f){
+    return x;
+  }else{
+    if(u > 2.0f){
+      // Use normal log for large arguments
+      return logf(u);
+    }else{
+      return logf(u)*(x/(u-1.0f));
+    }
+  }
+}
+
+#if _MSV_VER <= 1500
+#include <complex>
+
+inline float hypotf(float x, float y){
+	return abs(std::complex<float>(x,y));
+}
+
+inline double hypot(double x, double y){
+	return _hypot(x,y);
+}
+
+#endif // _MSC_VER <= 1500
+
+#endif // __CUDACC__
+
+#endif // _MSC_VER
+
+} // namespace complex
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrig.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrig.h
new file mode 100644
index 0000000000000000000000000000000000000000..4955ec5bfa5c1d3f9f48dbe2ac33450d1b9f5d3b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrig.h
@@ -0,0 +1,785 @@
+/*
+ *  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;
+
+__host__ __device__
+inline void raise_inexact(){
+  const volatile float tiny = 7.888609052210118054117286e-31; /* 0x1p-100; */
+  // needs the volatile to prevent compiler from ignoring it
+  volatile float junk = 1 + tiny;
+  (void)junk;
+}
+
+__host__ __device__ inline complex<double> clog_for_large_values(complex<double> z);
+
+/*
+ * Testing indicates that all these functions are accurate up to 4 ULP.
+ * The functions casin(h) and cacos(h) are about 2.5 times slower than asinh.
+ * The functions catan(h) are a little under 2 times slower than atanh.
+ *
+ * The code for casinh, casin, cacos, and cacosh comes first.  The code is
+ * rather complicated, and the four functions are highly interdependent.
+ *
+ * The code for catanh and catan comes at the end.  It is much simpler than
+ * the other functions, and the code for these can be disconnected from the
+ * rest of the code.
+ */
+
+/*
+ *			================================
+ *			| casinh, casin, cacos, cacosh |
+ *			================================
+ */
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * Throughout we use the convention z = x + I*y.
+ *
+ * casinh(z) = sign(x)*log(A+sqrt(A*A-1)) + I*asin(B)
+ * where
+ * A = (|z+I| + |z-I|) / 2
+ * B = (|z+I| - |z-I|) / 2 = y/A
+ *
+ * These formulas become numerically unstable:
+ *   (a) for Re(casinh(z)) when z is close to the line segment [-I, I] (that
+ *       is, Re(casinh(z)) is close to 0);
+ *   (b) for Im(casinh(z)) when z is close to either of the intervals
+ *       [I, I*infinity) or (-I*infinity, -I] (that is, |Im(casinh(z))| is
+ *       close to PI/2).
+ *
+ * These numerical problems are overcome by defining
+ * f(a, b) = (hypot(a, b) - b) / 2 = a*a / (hypot(a, b) + b) / 2
+ * Then if A < A_crossover, we use
+ *   log(A + sqrt(A*A-1)) = log1p((A-1) + sqrt((A-1)*(A+1)))
+ *   A-1 = f(x, 1+y) + f(x, 1-y)
+ * and if B > B_crossover, we use
+ *   asin(B) = atan2(y, sqrt(A*A - y*y)) = atan2(y, sqrt((A+y)*(A-y)))
+ *   A-y = f(x, y+1) + f(x, y-1)
+ * where without loss of generality we have assumed that x and y are
+ * non-negative.
+ *
+ * Much of the difficulty comes because the intermediate computations may
+ * produce overflows or underflows.  This is dealt with in the paper by Hull
+ * et al by using exception handling.  We do this by detecting when
+ * computations risk underflow or overflow.  The hardest part is handling the
+ * underflows when computing f(a, b).
+ *
+ * Note that the function f(a, b) does not appear explicitly in the paper by
+ * Hull et al, but the idea may be found on pages 308 and 309.  Introducing the
+ * function f(a, b) allows us to concentrate many of the clever tricks in this
+ * paper into one function.
+ */
+
+/*
+ * Function f(a, b, hypot_a_b) = (hypot(a, b) - b) / 2.
+ * Pass hypot(a, b) as the third argument.
+ */
+__host__ __device__
+inline double
+f(double a, double b, double hypot_a_b)
+{
+  if (b < 0)
+    return ((hypot_a_b - b) / 2);
+  if (b == 0)
+    return (a / 2);
+  return (a * a / (hypot_a_b + b) / 2);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__
+inline void
+do_hard_work(double x, double y, double *rx, int *B_is_usable, double *B,
+			double *sqrt_A2my2, double *new_y)
+{
+  double R, S, A; /* A, B, R, and S are as in Hull et al. */
+  double Am1, Amy; /* A-1, A-y. */
+  const double A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const double FOUR_SQRT_MIN = 5.966672584960165394632772e-154; /* =0x1p-509; >= 4 * sqrt(DBL_MIN) */
+  const double B_crossover = 0.6417; /* suggested by Hull et al */
+
+  R = hypot(x, y + 1);		/* |z+I| */
+  S = hypot(x, y - 1);		/* |z-I| */
+
+  /* A = (|z+I| + |z-I|) / 2 */
+  A = (R + S) / 2;
+  /*
+   * Mathematically A >= 1.  There is a small chance that this will not
+   * be so because of rounding errors.  So we will make certain it is
+   * so.
+   */
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    /*
+     * Am1 = fp + fm, where fp = f(x, 1+y), and fm = f(x, 1-y).
+     * rx = log1p(Am1 + sqrt(Am1*(A+1)))
+     */
+    if (y == 1 && x < DBL_EPSILON * DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *rx = sqrt(x);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON^2/128 >= FOUR_SQRT_MIN
+       */
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1p(Am1 + sqrt(Am1 * (A + 1)));
+    } else if (y < 1) {
+      /*
+       * fp = x*x/(1+y)/4, fm = x*x/(1-y)/4, and
+       * A = 1 (inexactly).
+       */
+      *rx = x / sqrt((1 - y) * (1 + y));
+    } else {		/* if (y > 1) */
+      /*
+       * A-1 = y-1 (inexactly).
+       */
+      *rx = log1p((y - 1) + sqrt((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = log(A + sqrt(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    /*
+     * Avoid a possible underflow caused by y/A.  For casinh this
+     * would be legitimate, but will be picked up by invoking atan2
+     * later on.  For cacos this would not be legitimate.
+     */
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / DBL_EPSILON);
+    *new_y = y * (2 / DBL_EPSILON);
+    return;
+  }
+
+  /* B = (|z+I| - |z-I|) / 2 = y/A */
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    /*
+     * Amy = fp + fm, where fp = f(x, y+1), and fm = f(x, y-1).
+     * sqrt_A2my2 = sqrt(Amy*(A+y))
+     */
+    if (y == 1 && x < DBL_EPSILON / 128) {
+      /*
+       * fp is of order x^2, and fm = x/2.
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt(x) * sqrt((A + y) / 2);
+    } else if (x >= DBL_EPSILON * fabs(y - 1)) {
+      /*
+       * Underflow will not occur because
+       * x >= DBL_EPSILON/128 >= FOUR_SQRT_MIN
+       * and
+       * x >= DBL_EPSILON^2 >= FOUR_SQRT_MIN
+       */
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrt(Amy * (A + y));
+    } else if (y > 1) {
+      /*
+       * fp = x*x/(y+1)/4, fm = x*x/(y-1)/4, and
+       * A = y (inexactly).
+       *
+       * y < RECIP_EPSILON.  So the following
+       * scaling should avoid any underflow problems.
+       */
+      *sqrt_A2my2 = x * (4 / DBL_EPSILON / DBL_EPSILON) * y /
+	sqrt((y + 1) * (y - 1));
+      *new_y = y * (4 / DBL_EPSILON / DBL_EPSILON);
+    } else {		/* if (y < 1) */
+      /*
+       * fm = 1-y >= DBL_EPSILON, fp is of order x^2, and
+       * A = 1 (inexactly).
+       */
+      *sqrt_A2my2 = sqrt((1 - y) * (1 + y));
+    }
+  }
+}
+
+/*
+ * casinh(z) = z + O(z^3)   as z -> 0
+ *
+ * casinh(z) = sign(x)*clog(sign(x)*z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the imaginary part as well, because
+ * Im(casinh(z)) = sign(x)*atan2(sign(x)*y, fabs(x)) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> casinh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<double> w;
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
+    if (isinf(x))
+      return (complex<double>(x, y + y));
+    /* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
+    if (isinf(y))
+      return (complex<double>(y, x + x));
+    /* casinh(NaN + I*0) = NaN + I*0 */
+    if (y == 0)
+      return (complex<double>(x + x, y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0.0), x + 0.0 + (y + 0.0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<double>(copysign(w.real(), x), copysign(w.imag(), y)));
+  }
+
+  /* Avoid spuriously raising inexact for z = 0. */
+  if (x == 0 && y == 0)
+    return (z);
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asin(B);
+  else
+    ry = atan2(new_y, sqrt_A2my2);
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * casin(z) = reverse(casinh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double> casin(complex<double> z)
+{
+  complex<double> w = casinh(complex<double>(z.imag(), z.real()));
+
+  return (complex<double>(w.imag(), w.real()));
+}
+
+/*
+ * cacos(z) = PI/2 - casin(z)
+ * but do the computation carefully so cacos(z) is accurate when z is
+ * close to 1.
+ *
+ * cacos(z) = PI/2 - z + O(z^3)   as z -> 0
+ *
+ * cacos(z) = -sign(y)*I*clog(z) + O(1/z^2)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(cacos(z)) = atan2(fabs(y), x) + O(y/z^3)
+ *    as z -> infinity, uniformly in y
+ */
+__host__ __device__ inline
+complex<double> cacos(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<double> w;
+  const double pio2_hi = 1.5707963267948966e0; /*  0x1921fb54442d18.0p-52 */
+  const volatile double pio2_lo = 6.1232339957367659e-17;	/*  0x11a62633145c07.0p-106 */
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabs(x);
+  ay = fabs(y);
+
+  if (isnan(x) || isnan(y)) {
+    /* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
+    if (isinf(x))
+      return (complex<double>(y + y, -infinity<double>()));
+    /* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
+    if (isinf(y))
+      return (complex<double>(x + x, -y));
+    /* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
+    if (x == 0)
+      return (complex<double>(pio2_hi + pio2_lo, y + y));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    /* clog...() will raise inexact unless x or y is infinite. */
+    w = clog_for_large_values(z);
+    rx = fabs(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<double>(rx, ry));
+  }
+
+  /* Avoid spuriously raising inexact for z = 1. */
+  if (x == 1.0 && y == 0.0)
+    return (complex<double>(0, -y));
+
+  /* All remaining cases are inexact. */
+  raise_inexact();
+
+  const double SQRT_6_EPSILON = 3.6500241499888571e-8; /*  0x13988e1409212e.0p-77 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<double>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acos(B);
+    else
+      rx = acos(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2(sqrt_A2mx2, new_x);
+    else
+      rx = atan2(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<double>(rx, ry));
+}
+
+/*
+ * cacosh(z) = I*cacos(z) or -I*cacos(z)
+ * where the sign is chosen so Re(cacosh(z)) >= 0.
+ */
+__host__ __device__ inline
+complex<double> cacosh(complex<double> z)
+{
+  complex<double> w;
+  double rx, ry;
+
+  w = cacos(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<double>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<double>(fabs(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<double>(ry, ry));
+  return (complex<double>(fabs(ry), copysign(rx, z.imag())));
+}
+
+/*
+ * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+ */
+__host__ __device__ inline
+complex<double> clog_for_large_values(complex<double> z)
+{
+  double x, y;
+  double ax, ay, t;
+  const double m_e = 2.7182818284590452e0; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * Avoid overflow in hypot() when x and y are both very large.
+   * Divide x and y by E, and then add 1 to the logarithm.  This depends
+   * on E being larger than sqrt(2).
+   * Dividing by E causes an insignificant loss of accuracy; however
+   * this method is still poor since it is uneccessarily slow.
+   */
+  if (ax > DBL_MAX / 2)
+    return (complex<double>(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
+
+  /*
+   * Avoid overflow when x or y is large.  Avoid underflow when x or
+   * y is small.
+   */
+  const double QUARTER_SQRT_MAX = 5.966672584960165394632772e-154; /* = 0x1p509; <= sqrt(DBL_MAX) / 4 */
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<double>(log(hypot(x, y)), atan2(y, x)));
+
+  return (complex<double>(log(ax * ax + ay * ay) / 2, atan2(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+   * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+   * Assumes x*x and y*y will not overflow.
+   * Assumes x and y are finite.
+   * Assumes y is non-negative.
+   * Assumes fabs(x) >= DBL_EPSILON.
+   */
+__host__ __device__
+inline double sum_squares(double x, double y)
+{
+  const double SQRT_MIN =	1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+/*
+ * real_part_reciprocal(x, y) = Re(1/(x+I*y)) = x/(x*x + y*y).
+ * Assumes x and y are not NaN, and one of x and y is larger than
+ * RECIP_EPSILON.  We avoid unwarranted underflow.  It is important to not use
+ * the code creal(1/z), because the imaginary part may produce an unwanted
+ * underflow.
+ * This is only called in a context where inexact is always raised before
+ * the call, so no effort is made to avoid or force inexact.
+ */
+__host__ __device__
+inline double real_part_reciprocal(double x, double y)
+{
+  double scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  /*
+   * This code is inspired by the C99 document n1124.pdf, Section G.5.1,
+   * example 2.
+   */
+  get_high_word(hx, x);
+  ix = hx & 0x7ff00000;
+  get_high_word(hy, y);
+  iy = hy & 0x7ff00000;
+  //#define	BIAS	(DBL_MAX_EXP - 1)
+  const int BIAS = DBL_MAX_EXP - 1;
+  /* XXX more guard digits are useful iff there is extra precision. */
+  //#define	CUTOFF	(DBL_MANT_DIG / 2 + 1)	/* just half or 1 guard digit */
+  const int CUTOFF = (DBL_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 20 || isinf(x))
+    return (1 / x);		/* +-Inf -> +-0 is special */
+  if (iy - ix >= CUTOFF << 20)
+    return (x / y / y);	/* should avoid double div, but hard */
+  if (ix <= (BIAS + DBL_MAX_EXP / 2 - CUTOFF) << 20)
+    return (x / (x * x + y * y));
+  scale = 1;
+  set_high_word(scale, 0x7ff00000 - ix);	/* 2**(1-ilogb(x)) */
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+
+/*
+ * catanh(z) = log((1+z)/(1-z)) / 2
+ *           = log1p(4*x / |z-1|^2) / 4
+ *             + I * atan2(2*y, (1-x)*(1+x)-y*y) / 2
+ *
+ * catanh(z) = z + O(z^3)   as z -> 0
+ *
+ * catanh(z) = 1/z + sign(y)*I*PI/2 + O(1/z^3)   as z -> infinity
+ * The above formula works for the real part as well, because
+ * Re(catanh(z)) = x/|z|^2 + O(x/z^4)
+ *    as z -> infinity, uniformly in x
+ */
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<double> catanh(complex<double> z)
+{
+  double x, y, ax, ay, rx, ry;
+  const volatile double pio2_lo = 6.1232339957367659e-17; /*  0x11a62633145c07.0p-106 */
+  const double pio2_hi = 1.5707963267948966e0;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabs(x);
+  ay = fabs(y);
+
+  /* This helps handle many cases. */
+  if (y == 0 && ax <= 1)
+    return (complex<double>(atanh(x), y));
+
+  /* To ensure the same accuracy as atan(), and to filter out z = 0. */
+  if (x == 0)
+    return (complex<double>(x, atan(y)));
+
+  if (isnan(x) || isnan(y)) {
+    /* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
+    if (isinf(x))
+      return (complex<double>(copysign(0.0, x), y + y));
+    /* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
+    if (isinf(y))
+      return (complex<double>(copysign(0.0, x),
+			      copysign(pio2_hi + pio2_lo, y)));
+    /*
+     * All other cases involving NaN return NaN + I*NaN.
+     * C99 leaves it optional whether to raise invalid if one of
+     * the arguments is not NaN, so we opt not to raise it.
+     */
+    return (complex<double>(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
+  }
+
+  const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<double>(real_part_reciprocal(x, y),
+			    copysign(pio2_hi + pio2_lo, y)));
+
+  const double SQRT_3_EPSILON = 2.5809568279517849e-8; /*  0x1bb67ae8584caa.0p-78 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    /*
+     * z = 0 was filtered out above.  All other cases must raise
+     * inexact, but this is the only only that needs to do it
+     * explicitly.
+     */
+    raise_inexact();
+    return (z);
+  }
+
+  const double m_ln2 = 6.9314718055994531e-1; /*  0x162e42fefa39ef.0p-53 */
+  if (ax == 1 && ay < DBL_EPSILON)
+    rx = (m_ln2 - log(ay)) / 2;
+  else
+    rx = log1p(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2(2.0, -ay) / 2;
+  else if (ay < DBL_EPSILON)
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<double>(copysign(rx, x), copysign(ry, y)));
+}
+
+/*
+ * catan(z) = reverse(catanh(reverse(z)))
+ * where reverse(x + I*y) = y + I*x = I*conj(z).
+ */
+__host__ __device__ inline
+complex<double>catan(complex<double> z)
+{
+  complex<double> w = catanh(complex<double>(z.imag(), z.real()));
+  return (complex<double>(w.imag(), w.real()));
+}
+
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acos(const complex<ValueType>& z){
+  const complex<ValueType> ret = thrust::asin(z);
+  const ValueType pi = ValueType(3.14159265358979323846);
+  return complex<ValueType>(pi/2 - ret.real(),-ret.imag());
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asin(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*asinh(i*z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atan(const complex<ValueType>& z){
+  const complex<ValueType> i(0,1);
+  return -i*thrust::atanh(i*z);
+}
+
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> acosh(const complex<ValueType>& z){
+  thrust::complex<ValueType> ret((z.real() - z.imag()) * (z.real() + z.imag()) - ValueType(1.0),
+				 ValueType(2.0) * z.real() * z.imag());
+  ret = thrust::sqrt(ret);
+  if (z.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  ret += z;
+  ret = thrust::log(ret);
+  if (ret.real() < ValueType(0.0)){
+    ret = -ret;
+  }
+  return ret;
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> asinh(const complex<ValueType>& z){
+  return thrust::log(thrust::sqrt(z*z+ValueType(1))+z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> atanh(const complex<ValueType>& z){
+  ValueType imag2 = z.imag() *  z.imag();
+  ValueType n = ValueType(1.0) + z.real();
+  n = imag2 + n * n;
+
+  ValueType d = ValueType(1.0) - z.real();
+  d = imag2 + d * d;
+  complex<ValueType> ret(ValueType(0.25) * (std::log(n) - std::log(d)),0);
+
+  d = ValueType(1.0) -  z.real() * z.real() - imag2;
+
+  ret.imag(ValueType(0.5) * std::atan2(ValueType(2.0) * z.imag(), d));
+  return ret;
+}
+
+template <>
+__host__ __device__
+inline complex<double> acos(const complex<double>& z){
+  return detail::complex::cacos(z);
+}
+
+template <>
+__host__ __device__
+inline complex<double> asin(const complex<double>& z){
+  return detail::complex::casin(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atan(const complex<double>& z){
+  return detail::complex::catan(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<double> acosh(const complex<double>& z){
+  return detail::complex::cacosh(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<double> asinh(const complex<double>& z){
+  return detail::complex::casinh(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<double> atanh(const complex<double>& z){
+  return detail::complex::catanh(z);
+}
+#endif
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrigf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrigf.h
new file mode 100644
index 0000000000000000000000000000000000000000..c06791311a82a3780117838a46f838e0c5294a83
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/catrigf.h
@@ -0,0 +1,500 @@
+/*
+ *  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/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <thrust/detail/config.h>
+#include <cfloat>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{		      	
+
+using thrust::complex;
+  
+__host__ __device__ inline
+      complex<float> clog_for_large_values(complex<float> z);
+
+/*
+ * The algorithm is very close to that in "Implementing the complex arcsine
+ * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
+ * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
+ * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
+ * http://dl.acm.org/citation.cfm?id=275324.
+ *
+ * See catrig.c for complete comments.
+ *
+ * XXX comments were removed automatically, and even short ones on the right
+ * of statements were removed (all of them), contrary to normal style.  Only
+ * a few comments on the right of declarations remain.
+ */
+
+__host__ __device__
+inline float
+f(float a, float b, float hypot_a_b)
+{
+  if (b < 0.0f)
+    return ((hypot_a_b - b) / 2.0f);
+  if (b == 0.0f)
+    return (a / 2.0f);
+  return (a * a / (hypot_a_b + b) / 2.0f);
+}
+
+/*
+ * All the hard work is contained in this function.
+ * x and y are assumed positive or zero, and less than RECIP_EPSILON.
+ * Upon return:
+ * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
+ * B_is_usable is set to 1 if the value of B is usable.
+ * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
+ * If returning sqrt_A2my2 has potential to result in an underflow, it is
+ * rescaled, and new_y is similarly rescaled.
+ */
+__host__ __device__ 
+inline void
+do_hard_work(float x, float y, float *rx, int *B_is_usable, float *B,
+	     float *sqrt_A2my2, float *new_y)
+{
+  float R, S, A; /* A, B, R, and S are as in Hull et al. */
+  float Am1, Amy; /* A-1, A-y. */
+  const float A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
+  const float FOUR_SQRT_MIN = 4.336808689942017736029811e-19f;; /* =0x1p-61; >= 4 * sqrt(FLT_MIN) */
+  const float B_crossover = 0.6417f; /* suggested by Hull et al */
+  R = hypotf(x, y + 1);
+  S = hypotf(x, y - 1);
+
+  A = (R + S) / 2;
+  if (A < 1)
+    A = 1;
+
+  if (A < A_crossover) {
+    if (y == 1 && x < FLT_EPSILON * FLT_EPSILON / 128) {
+      *rx = sqrtf(x);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
+      *rx = log1pf(Am1 + sqrtf(Am1 * (A + 1)));
+    } else if (y < 1) {
+      *rx = x / sqrtf((1 - y) * (1 + y));
+    } else {
+      *rx = log1pf((y - 1) + sqrtf((y - 1) * (y + 1)));
+    }
+  } else {
+    *rx = logf(A + sqrtf(A * A - 1));
+  }
+
+  *new_y = y;
+
+  if (y < FOUR_SQRT_MIN) {
+    *B_is_usable = 0;
+    *sqrt_A2my2 = A * (2 / FLT_EPSILON);
+    *new_y = y * (2 / FLT_EPSILON);
+    return;
+  }
+
+  *B = y / A;
+  *B_is_usable = 1;
+
+  if (*B > B_crossover) {
+    *B_is_usable = 0;
+    if (y == 1 && x < FLT_EPSILON / 128) {
+      *sqrt_A2my2 = sqrtf(x) * sqrtf((A + y) / 2);
+    } else if (x >= FLT_EPSILON * fabsf(y - 1)) {
+      Amy = f(x, y + 1, R) + f(x, y - 1, S);
+      *sqrt_A2my2 = sqrtf(Amy * (A + y));
+    } else if (y > 1) {
+      *sqrt_A2my2 = x * (4 / FLT_EPSILON / FLT_EPSILON) * y /
+	sqrtf((y + 1) * (y - 1));
+      *new_y = y * (4 / FLT_EPSILON / FLT_EPSILON);
+    } else {
+      *sqrt_A2my2 = sqrtf((1 - y) * (1 + y));
+    }
+  }
+
+}
+
+__host__ __device__ inline
+complex<float>
+casinhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
+  int B_is_usable;
+  complex<float> w;
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(x, y + y));
+    if (isinf(y))
+      return (complex<float>(y, x + x));
+    if (y == 0)
+      return (complex<float>(x + x, y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    if (signbit(x) == 0)
+      w = clog_for_large_values(z) + m_ln2;
+    else
+      w = clog_for_large_values(-z) + m_ln2;
+    return (complex<float>(copysignf(w.real(), x),
+			   copysignf(w.imag(), y)));
+  }
+
+  if (x == 0 && y == 0)
+    return (z);
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (z);
+
+  do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
+  if (B_is_usable)
+    ry = asinf(B);
+  else
+    ry = atan2f(new_y, sqrt_A2my2);
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float> casinf(complex<float> z)
+{
+  complex<float> w = casinhf(complex<float>(z.imag(), z.real()));
+
+  return (complex<float>(w.imag(), w.real()));
+}
+
+__host__ __device__ inline
+complex<float> cacosf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
+  int sx, sy;
+  int B_is_usable;
+  complex<float> w;
+  const float pio2_hi = 1.5707963267948966e0f; /*  0x1921fb54442d18.0p-52 */
+  const volatile float pio2_lo = 6.1232339957367659e-17f;	/*  0x11a62633145c07.0p-106 */
+  const float m_ln2 = 6.9314718055994531e-1f; /*  0x162e42fefa39ef.0p-53 */
+
+  x = z.real();
+  y = z.imag();
+  sx = signbit(x);
+  sy = signbit(y);
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(y + y, -infinity<float>()));
+    if (isinf(y))
+      return (complex<float>(x + x, -y));
+    if (x == 0)
+      return (complex<float>(pio2_hi + pio2_lo, y + y));
+    return (complex<float>(x + 0.0f + (y + 0), x + 0.0f + (y + 0)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
+    w = clog_for_large_values(z);
+    rx = fabsf(w.imag());
+    ry = w.real() + m_ln2;
+    if (sy == 0)
+      ry = -ry;
+    return (complex<float>(rx, ry));
+  }
+
+  if (x == 1 && y == 0)
+    return (complex<float>(0, -y));
+
+  raise_inexact();
+
+  const float SQRT_6_EPSILON = 8.4572793338e-4f;	/*  0xddb3d7.0p-34 */
+  if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
+    return (complex<float>(pio2_hi - (x - pio2_lo), -y));
+
+  do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
+  if (B_is_usable) {
+    if (sx == 0)
+      rx = acosf(B);
+    else
+      rx = acosf(-B);
+  } else {
+    if (sx == 0)
+      rx = atan2f(sqrt_A2mx2, new_x);
+    else
+      rx = atan2f(sqrt_A2mx2, -new_x);
+  }
+  if (sy == 0)
+    ry = -ry;
+  return (complex<float>(rx, ry));
+}
+
+__host__ __device__ inline
+complex<float> cacoshf(complex<float> z)
+{
+  complex<float> w;
+  float rx, ry;
+
+  w = cacosf(z);
+  rx = w.real();
+  ry = w.imag();
+  /* cacosh(NaN + I*NaN) = NaN + I*NaN */
+  if (isnan(rx) && isnan(ry))
+    return (complex<float>(ry, rx));
+  /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
+  /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
+  if (isnan(rx))
+    return (complex<float>(fabsf(ry), rx));
+  /* cacosh(0 + I*NaN) = NaN + I*NaN */
+  if (isnan(ry))
+    return (complex<float>(ry, ry));
+  return (complex<float>(fabsf(ry), copysignf(rx, z.imag())));
+}
+
+  /*
+   * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
+   */
+__host__ __device__ inline
+complex<float> clog_for_large_values(complex<float> z)
+{
+  float x, y;
+  float ax, ay, t;
+  const float m_e = 2.7182818284590452e0f; /*  0x15bf0a8b145769.0p-51 */
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  if (ax > FLT_MAX / 2)
+    return (complex<float>(logf(hypotf(x / m_e, y / m_e)) + 1,
+			   atan2f(y, x)));
+
+  const float QUARTER_SQRT_MAX = 2.3058430092136939520000000e+18f; /* = 0x1p61; <= sqrt(FLT_MAX) / 4 */
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
+    return (complex<float>(logf(hypotf(x, y)), atan2f(y, x)));
+
+  return (complex<float>(logf(ax * ax + ay * ay) / 2, atan2f(y, x)));
+}
+
+/*
+ *				=================
+ *				| catanh, catan |
+ *				=================
+ */
+
+/*
+ * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
+ * Assumes x*x and y*y will not overflow.
+ * Assumes x and y are finite.
+ * Assumes y is non-negative.
+ * Assumes fabsf(x) >= FLT_EPSILON.
+ */
+__host__ __device__
+inline float sum_squares(float x, float y)
+{
+  const float SQRT_MIN =	1.084202172485504434007453e-19f; /* 0x1p-63; >= sqrt(FLT_MIN) */
+  /* Avoid underflow when y is small. */
+  if (y < SQRT_MIN)
+    return (x * x);
+
+  return (x * x + y * y);
+}
+
+__host__ __device__
+inline float real_part_reciprocal(float x, float y)
+{
+  float scale;
+  uint32_t hx, hy;
+  int32_t ix, iy;
+
+  get_float_word(hx, x);
+  ix = hx & 0x7f800000;
+  get_float_word(hy, y);
+  iy = hy & 0x7f800000;
+  //#define	BIAS	(FLT_MAX_EXP - 1)
+  const int BIAS = FLT_MAX_EXP - 1;
+  //#define	CUTOFF	(FLT_MANT_DIG / 2 + 1)
+  const int CUTOFF = (FLT_MANT_DIG / 2 + 1);
+  if (ix - iy >= CUTOFF << 23 || isinf(x))
+    return (1 / x);
+  if (iy - ix >= CUTOFF << 23)
+    return (x / y / y);
+  if (ix <= (BIAS + FLT_MAX_EXP / 2 - CUTOFF) << 23)
+    return (x / (x * x + y * y));
+  set_float_word(scale, 0x7f800000 - ix);
+  x *= scale;
+  y *= scale;
+  return (x / (x * x + y * y) * scale);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+__host__ __device__ inline
+complex<float> catanhf(complex<float> z)
+{
+  float x, y, ax, ay, rx, ry;
+  const volatile float pio2_lo = 6.1232339957367659e-17f; /*  0x11a62633145c07.0p-106 */
+  const float pio2_hi = 1.5707963267948966e0f;/*  0x1921fb54442d18.0p-52 */
+
+
+  x = z.real();
+  y = z.imag();
+  ax = fabsf(x);
+  ay = fabsf(y);
+
+
+  if (y == 0 && ax <= 1)
+    return (complex<float>(atanhf(x), y));
+
+  if (x == 0)
+    return (complex<float>(x, atanf(y)));
+
+  if (isnan(x) || isnan(y)) {
+    if (isinf(x))
+      return (complex<float>(copysignf(0, x), y + y));
+    if (isinf(y))
+      return (complex<float>(copysignf(0, x),
+			     copysignf(pio2_hi + pio2_lo, y)));
+    return (complex<float>(x + 0.0f + (y + 0.0f), x + 0.0f + (y + 0.0f)));
+  }
+
+  const float RECIP_EPSILON = 1.0f / FLT_EPSILON;
+  if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
+    return (complex<float>(real_part_reciprocal(x, y),
+			   copysignf(pio2_hi + pio2_lo, y)));
+
+  const float SQRT_3_EPSILON = 5.9801995673e-4f; /*  0x9cc471.0p-34 */
+  if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
+    raise_inexact();
+    return (z);
+  }
+
+  const float m_ln2 = 6.9314718056e-1f; /*  0xb17218.0p-24 */
+  if (ax == 1 && ay < FLT_EPSILON)
+    rx = (m_ln2 - logf(ay)) / 2;
+  else
+    rx = log1pf(4 * ax / sum_squares(ax - 1, ay)) / 4;
+
+  if (ax == 1)
+    ry = atan2f(2, -ay) / 2;
+  else if (ay < FLT_EPSILON)
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax)) / 2;
+  else
+    ry = atan2f(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
+
+  return (complex<float>(copysignf(rx, x), copysignf(ry, y)));
+}
+
+__host__ __device__ inline
+complex<float>catanf(complex<float> z){
+  complex<float> w = catanhf(complex<float>(z.imag(), z.real()));
+  return (complex<float>(w.imag(), w.real()));
+}
+#endif
+
+} // namespace complex
+
+} // namespace detail
+
+
+template <>
+__host__ __device__
+inline complex<float> acos(const complex<float>& z){
+  return detail::complex::cacosf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> asin(const complex<float>& z){
+  return detail::complex::casinf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atan(const complex<float>& z){
+  return detail::complex::catanf(z);
+}
+#endif
+
+template <>
+__host__ __device__
+inline complex<float> acosh(const complex<float>& z){
+  return detail::complex::cacoshf(z);
+}
+
+
+template <>
+__host__ __device__
+inline complex<float> asinh(const complex<float>& z){
+  return detail::complex::casinhf(z);
+}
+
+#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+template <>
+__host__ __device__
+inline complex<float> atanh(const complex<float>& z){
+  return detail::complex::catanhf(z);
+}
+#endif
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccosh.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccosh.h
new file mode 100644
index 0000000000000000000000000000000000000000..722dfcd843de8a85def1cdf6ad60a02d813a15a2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccosh.h
@@ -0,0 +1,215 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccosh.c
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{		      	
+
+/*
+ * Hyperbolic cosine of a complex argument z = x + i y.
+ *
+ * cosh(z) = cosh(x+iy)
+ *         = cosh(x) cos(y) + i sinh(x) sin(y).
+ *
+ * Exceptional values are noted in the comments within the source code.
+ * These values and the return value were taken from n1124.pdf.
+ */
+      
+__host__ __device__ inline
+thrust::complex<double> ccosh(const thrust::complex<double>& z){
+  
+
+  const double huge = 8.98846567431157953864652595395e+307; // 0x1p1023
+  double x, y, h;
+  uint32_t hx, hy, ix, iy, lx, ly;
+
+  x = z.real();
+  y = z.imag();
+
+  extract_words(hx, lx, x);
+  extract_words(hy, ly, y);
+
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+
+  /* Handle the nearly-non-exceptional cases where x and y are finite. */
+  if (ix < 0x7ff00000 && iy < 0x7ff00000) {
+    if ((iy | ly) == 0)
+      return (thrust::complex<double>(::cosh(x), x * y));
+    if (ix < 0x40360000)	/* small x: normal case */
+      return (thrust::complex<double>(::cosh(x) * ::cos(y), ::sinh(x) * ::sin(y)));
+
+    /* |x| >= 22, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x40862e42) {
+      /* x < 710: exp(|x|) won't overflow */
+      h = ::exp(::fabs(x)) * 0.5;
+      return (thrust::complex<double>(h * cos(y), copysign(h, x) * sin(y)));
+    } else if (ix < 0x4096bbaa) {
+      /* x < 1455: scale to avoid overflow */
+      thrust::complex<double> z_;
+      z_ = ldexp_cexp(thrust::complex<double>(fabs(x), y), -1);
+      return (thrust::complex<double>(z_.real(), z_.imag() * copysign(1.0, x)));
+    } else {
+      /* x >= 1455: the result always overflows */
+      h = huge * x;
+      return (thrust::complex<double>(h * h * cos(y), h * sin(y)));
+    }
+  }
+
+  /*
+   * cosh(+-0 +- I Inf) = dNaN + I sign(d(+-0, dNaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as dNaN.  Raise the invalid floating-point exception.
+   *
+   * cosh(+-0 +- I NaN) = d(NaN) + I sign(d(+-0, NaN))0.
+   * The sign of 0 in the result is unspecified.  Choice = normally
+   * the same as d(NaN).
+   */
+  if ((ix | lx) == 0 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, copysign(0.0, x * (y - y))));
+
+  /*
+   * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0.
+   *
+   * cosh(NaN +- I 0)   = d(NaN) + I sign(d(NaN, +-0))0.
+   * The sign of 0 in the result is unspecified.
+   */
+  if ((iy | ly) == 0 && ix >= 0x7ff00000) {
+    if (((hx & 0xfffff) | lx) == 0)
+      return (thrust::complex<double>(x * x, copysign(0.0, x) * y));
+    return (thrust::complex<double>(x * x, copysign(0.0, (x + x) * y)));
+  }
+
+  /*
+   * cosh(x +- I Inf) = dNaN + I dNaN.
+   * Raise the invalid floating-point exception for finite nonzero x.
+   *
+   * cosh(x + I NaN) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero x.  Choice = don't raise (except for signaling NaNs).
+   */
+  if (ix < 0x7ff00000 && iy >= 0x7ff00000)
+    return (thrust::complex<double>(y - y, x * (y - y)));
+
+  /*
+   * cosh(+-Inf + I NaN)  = +Inf + I d(NaN).
+   *
+   * cosh(+-Inf +- I Inf) = +Inf + I dNaN.
+   * The sign of Inf in the result is unspecified.  Choice = always +.
+   * Raise the invalid floating-point exception.
+   *
+   * cosh(+-Inf + I y)   = +Inf cos(y) +- I Inf sin(y)
+   */
+  if (ix >= 0x7ff00000 && ((hx & 0xfffff) | lx) == 0) {
+    if (iy >= 0x7ff00000)
+      return (thrust::complex<double>(x * x, x * (y - y)));
+    return (thrust::complex<double>((x * x) * cos(y), x * sin(y)));
+  }
+
+  /*
+   * cosh(NaN + I NaN)  = d(NaN) + I d(NaN).
+   *
+   * cosh(NaN +- I Inf) = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception.
+   * Choice = raise.
+   *
+   * cosh(NaN + I y)    = d(NaN) + I d(NaN).
+   * Optionally raises the invalid floating-point exception for finite
+   * nonzero y.  Choice = don't raise (except for signaling NaNs).
+   */
+  return (thrust::complex<double>((x * x) * (y - y), (x + x) * (y - y)));
+}
+
+
+__host__ __device__ inline
+thrust::complex<double> ccos(const thrust::complex<double>& z){	
+  /* ccos(z) = ccosh(I * z) */
+  return (ccosh(thrust::complex<double>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cos(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cos(re) * std::cosh(im), 
+			    -std::sin(re) * std::sinh(im));
+}
+  
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> cosh(const complex<ValueType>& z){
+  const ValueType re = z.real();
+  const ValueType im = z.imag();
+  return complex<ValueType>(std::cosh(re) * std::cos(im), 
+			    std::sinh(re) * std::sin(im));
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cos(const thrust::complex<double>& z){
+  return detail::complex::ccos(z);
+}
+
+template <>
+__host__ __device__
+inline thrust::complex<double> cosh(const thrust::complex<double>& z){
+  return detail::complex::ccosh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccoshf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccoshf.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa43f120826a4013092258b9a563e5330b926333
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ccoshf.h
@@ -0,0 +1,143 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*-
+ * Copyright (c) 2005 Bruce D. Evans and Steven G. Kargl
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/s_ccoshf.c
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{		      	
+
+using thrust::complex;
+      
+__host__ __device__ inline
+complex<float> ccoshf(const complex<float>& z){
+  float x, y, h;
+  uint32_t hx, hy, ix, iy;
+  const float huge = 1.70141183460469231731687303716e+38; //0x1p127;	
+  
+  
+  x = z.real();
+  y = z.imag();
+  
+  get_float_word(hx, x);
+  get_float_word(hy, y);
+  
+  ix = 0x7fffffff & hx;
+  iy = 0x7fffffff & hy;
+  if (ix < 0x7f800000 && iy < 0x7f800000) {
+    if (iy == 0){
+      return (complex<float>(coshf(x), x * y));
+    }
+    if (ix < 0x41100000){	/* small x: normal case */
+      return (complex<float>(coshf(x) * cosf(y), sinhf(x) * sinf(y)));
+    }
+    /* |x| >= 9, so cosh(x) ~= exp(|x|) */
+    if (ix < 0x42b17218) {
+      /* x < 88.7: expf(|x|) won't overflow */
+      h = expf(fabsf(x)) * 0.5f;
+      return (complex<float>(h * cosf(y), copysignf(h, x) * sinf(y)));
+    } else if (ix < 0x4340b1e7) {
+      /* x < 192.7: scale to avoid overflow */
+      thrust::complex<float> z_;
+      z_ = ldexp_cexpf(complex<float>(fabsf(x), y), -1);
+      return (complex<float>(z_.real(), z_.imag() * copysignf(1.0f, x)));
+    } else {
+      /* x >= 192.7: the result always overflows */
+      h = huge * x;
+      return (complex<float>(h * h * cosf(y), h * sinf(y)));
+    }
+  }
+  
+  if (ix == 0 && iy >= 0x7f800000){
+    return (complex<float>(y - y, copysignf(0.0f, x * (y - y))));
+  }
+  if (iy == 0 && ix >= 0x7f800000) {
+    if ((hx & 0x7fffff) == 0)
+      return (complex<float>(x * x, copysignf(0.0f, x) * y));
+    return (complex<float>(x * x, copysignf(0.0f, (x + x) * y)));
+  }
+  
+  if (ix < 0x7f800000 && iy >= 0x7f800000){
+    return (complex<float>(y - y, x * (y - y)));
+  }
+  
+  if (ix >= 0x7f800000 && (hx & 0x7fffff) == 0) {
+    if (iy >= 0x7f800000)
+      return (complex<float>(x * x, x * (y - y)));
+    return (complex<float>((x * x) * cosf(y), x * sinf(y)));
+  }
+  return (complex<float>((x * x) * (y - y), (x + x) * (y - y)));
+}
+  
+__host__ __device__ inline
+complex<float> ccosf(const complex<float>& z){	
+  return (ccoshf(complex<float>(-z.imag(), z.real())));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> cos(const complex<float>& z){
+  return detail::complex::ccosf(z);
+}
+  
+template <>
+__host__ __device__
+inline complex<float> cosh(const complex<float>& z){
+  return detail::complex::ccoshf(z);
+}
+  
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexp.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexp.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0c8c07d2508bbca9328b69a2af5458f82232013
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexp.h
@@ -0,0 +1,185 @@
+/*
+ *  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
+ */
+__host__ __device__ inline
+	double frexp_exp(double x, int *expt){
+  const uint32_t k = 1799;		/* constant for reduction */
+  const double kln2 =  1246.97177782734161156;	/* k * ln2 */
+	
+  double exp_x;
+  uint32_t hx;
+	
+  /*
+   * We use exp(x) = exp(x - kln2) * 2**k, carefully chosen to
+   * minimize |exp(kln2) - 2**k|.  We also scale the exponent of
+   * exp_x to MAX_EXP so that the result can be multiplied by
+   * a tiny number without losing accuracy due to denormalization.
+   */
+  exp_x = exp(x - kln2);
+  get_high_word(hx, exp_x);
+  *expt = (hx >> 20) - (0x3ff + 1023) + k;
+  set_high_word(exp_x, (hx & 0xfffff) | ((0x3ff + 1023) << 20));
+  return (exp_x);
+}
+      
+      
+__host__ __device__ inline
+complex<double>	ldexp_cexp(complex<double> z, int expt){
+  double x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+	
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_exp(x, &ex_expt);
+  expt += ex_expt;
+	
+  /*
+   * Arrange so that scale1 * scale2 == 2**expt.  We use this to
+   * compensate for scalbn being horrendously slow.
+   */
+  half_expt = expt / 2;
+  insert_words(scale1, (0x3ff + half_expt) << 20, 0);
+  half_expt = expt - half_expt;
+  insert_words(scale2, (0x3ff + half_expt) << 20, 0);
+	
+  return (complex<double>(cos(y) * exp_x * scale1 * scale2,
+			  sin(y) * exp_x * scale1 * scale2));
+}
+	
+
+__host__ __device__ inline
+complex<double> cexp(const complex<double>& z){
+  double x, y, exp_x;
+  uint32_t hx, hy, lx, ly;
+
+  const uint32_t
+    exp_ovfl  = 0x40862e42,			/* high bits of MAX_EXP * ln2 ~= 710 */
+    cexp_ovfl = 0x4096b8e4;			/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+	  
+  x = z.real();
+  y = z.imag();
+	  
+  extract_words(hy, ly, y);
+  hy &= 0x7fffffff;
+	  
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if ((hy | ly) == 0)
+    return (complex<double>(exp(x), y));
+  extract_words(hx, lx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if (((hx & 0x7fffffff) | lx) == 0)
+    return (complex<double>(cos(y), sin(y)));
+	  
+  if (hy >= 0x7ff00000) {
+    if (lx != 0 || (hx & 0x7fffffff) != 0x7ff00000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<double>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<double>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<double>(x, y - y));
+    }
+  }
+	  
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 709.7 and 1454.3, so we must scale to avoid
+     * overflow in exp(x).
+     */
+    return (ldexp_cexp(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<double>(exp_x * cos(y), exp_x * sin(y)));
+  }
+}
+	
+} // namespace complex
+ 
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> exp(const complex<ValueType>& z){    
+  return polar(std::exp(z.real()),z.imag());
+}
+
+template <>
+__host__ __device__
+inline complex<double> exp(const complex<double>& z){    
+  return detail::complex::cexp(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexpf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexpf.h
new file mode 100644
index 0000000000000000000000000000000000000000..cae030fe7bbfbf8559179a1c71061de96e8afef7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cexpf.h
@@ -0,0 +1,163 @@
+/*
+ *  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{
+
+__host__ __device__ inline
+float frexp_expf(float x, int *expt){
+  const uint32_t k = 235;                 /* constant for reduction */
+  const float kln2 =  162.88958740F;       /* k * ln2 */
+	
+  // should this be a double instead?
+  float exp_x;
+  uint32_t hx;
+	
+  exp_x = expf(x - kln2);
+  get_float_word(hx, exp_x);
+  *expt = (hx >> 23) - (0x7f + 127) + k;
+  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
+  return (exp_x);
+}
+      
+__host__ __device__ inline
+complex<float> 
+ldexp_cexpf(complex<float> z, int expt)
+{
+  float x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+	
+  x = z.real();
+  y = z.imag();
+  exp_x = frexp_expf(x, &ex_expt);
+  expt += ex_expt;
+	
+  half_expt = expt / 2;
+  set_float_word(scale1, (0x7f + half_expt) << 23);
+  half_expt = expt - half_expt;
+  set_float_word(scale2, (0x7f + half_expt) << 23);
+	
+  return (complex<float>(std::cos(y) * exp_x * scale1 * scale2,
+			 std::sin(y) * exp_x * scale1 * scale2));
+}
+      
+__host__ __device__ inline
+complex<float> cexpf(const complex<float>& z){
+  float x, y, exp_x;
+  uint32_t hx, hy;
+
+  const uint32_t
+    exp_ovfl  = 0x42b17218,		/* MAX_EXP * ln2 ~= 88.722839355 */
+    cexp_ovfl = 0x43400074;		/* (MAX_EXP - MIN_DENORM_EXP) * ln2 */
+
+  x = z.real();
+  y = z.imag();
+
+  get_float_word(hy, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if (hy == 0)
+    return (complex<float>(std::exp(x), y));
+  get_float_word(hx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if ((hx & 0x7fffffff) == 0){
+    return (complex<float>(std::cos(y), std::sin(y)));
+  }
+  if (hy >= 0x7f800000) {
+    if ((hx & 0x7fffffff) != 0x7f800000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return (complex<float>(y - y, y - y));
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return (complex<float>(0.0, 0.0));
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return (complex<float>(x, y - y));
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 88.7 and 192, so we must scale to avoid
+     * overflow in expf(x).
+     */
+    return (ldexp_cexpf(z, 0));
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = std::exp(x);
+    return (complex<float>(exp_x * std::cos(y), exp_x * std::sin(y)));
+  }
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> exp(const complex<float>& z){    
+  return detail::complex::cexpf(z);
+}    
+  
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clog.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clog.h
new file mode 100644
index 0000000000000000000000000000000000000000..b727121c395da5e8da775410d1e8f50e43f844d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clog.h
@@ -0,0 +1,214 @@
+/*
+ *  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 18 = 54/3 bits */
+__host__ __device__ inline
+double trim(double x){
+  uint32_t hi;
+  get_high_word(hi, x);
+  insert_words(x, hi &0xfffffff8, 0);
+  return x;
+}
+
+
+__host__ __device__ inline
+complex<double> clog(const complex<double>& z){
+
+  // Adapted from FreeBSDs msun
+  double x, y;
+  double ax, ay;
+  double x0, y0, x1, y1, x2, y2, t, hm1;
+  double val[12];
+  int i, sorted;
+  const double e = 2.7182818284590452354;
+
+  x = z.real();
+  y = z.imag();
+
+  /* Handle NaNs using the general formula to mix them right. */
+  if (x != x || y != y){
+    return (complex<double>(std::log(norm(z)), std::atan2(y, x)));
+  }
+
+  ax = std::abs(x);
+  ay = std::abs(y);
+  if (ax < ay) {
+    t = ax;
+    ax = ay;
+    ay = t;
+  }
+
+  /*
+   * To avoid unnecessary overflow, if x and y are very large, divide x
+   * and y by M_E, and then add 1 to the logarithm.  This depends on
+   * M_E being larger than sqrt(2).
+   * There is a potential loss of accuracy caused by dividing by M_E,
+   * but this case should happen extremely rarely.
+   */
+  //    if (ay > 5e307){
+  // For high values of ay -> hypotf(DBL_MAX,ay) = inf
+  // We expect that for values at or below ay = 5e307 this should not happen
+  if (ay > 5e307){
+    return (complex<double>(std::log(hypot(x / e, y / e)) + 1.0, std::atan2(y, x)));
+  }
+  if (ax == 1.) {
+    if (ay < 1e-150){
+      return (complex<double>((ay * 0.5) * ay, std::atan2(y, x)));
+    }
+    return (complex<double>(log1p(ay * ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Because atan2 and hypot conform to C99, this also covers all the
+   * edge cases when x or y are 0 or infinite.
+   */
+  if (ax < 1e-50 || ay < 1e-50 || ax > 1e50 || ay > 1e50){
+    return (complex<double>(std::log(hypot(x, y)), std::atan2(y, x)));
+  }
+
+  /*
+   * From this point on, we don't need to worry about underflow or
+   * overflow in calculating ax*ax or ay*ay.
+   */
+
+  /* Some easy cases. */
+
+  if (ax >= 1.0){
+    return (complex<double>(log1p((ax-1)*(ax+1) + ay*ay) * 0.5, atan2(y, x)));
+  }
+
+  if (ax*ax + ay*ay <= 0.7){
+    return (complex<double>(std::log(ax*ax + ay*ay) * 0.5, std::atan2(y, x)));
+  }
+
+  /*
+   * Take extra care so that ULP of real part is small if hypot(x,y) is
+   * moderately close to 1.
+   */
+
+
+  x0 = trim(ax);
+  ax = ax-x0;
+  x1 = trim(ax);
+  x2 = ax-x1;
+  y0 = trim(ay);
+  ay = ay-y0;
+  y1 = trim(ay);
+  y2 = ay-y1;
+
+  val[0] = x0*x0;
+  val[1] = y0*y0;
+  val[2] = 2*x0*x1;
+  val[3] = 2*y0*y1;
+  val[4] = x1*x1;
+  val[5] = y1*y1;
+  val[6] = 2*x0*x2;
+  val[7] = 2*y0*y2;
+  val[8] = 2*x1*x2;
+  val[9] = 2*y1*y2;
+  val[10] = x2*x2;
+  val[11] = y2*y2;
+
+  /* Bubble sort. */
+
+  do {
+    sorted = 1;
+    for (i=0;i<11;i++) {
+      if (val[i] < val[i+1]) {
+	sorted = 0;
+	t = val[i];
+	val[i] = val[i+1];
+	val[i+1] = t;
+      }
+    }
+  } while (!sorted);
+
+  hm1 = -1;
+  for (i=0;i<12;i++){
+    hm1 += val[i];
+  }
+  return (complex<double>(0.5 * log1p(hm1), atan2(y, x)));
+}
+
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log(const complex<ValueType>& z){
+  return complex<ValueType>(std::log(thrust::abs(z)),thrust::arg(z));
+}
+
+template <>
+__host__ __device__
+inline complex<double> log(const complex<double>& z){
+  return detail::complex::clog(z);
+}
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> log10(const complex<ValueType>& z){
+  // Using the explicit literal prevents compile time warnings in
+  // devices that don't support doubles
+  return thrust::log(z)/ValueType(2.30258509299404568402);
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clogf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clogf.h
new file mode 100644
index 0000000000000000000000000000000000000000..c72370c428424d4ccf18eea63fc6c5a6e7c90847
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/clogf.h
@@ -0,0 +1,200 @@
+/*
+ *  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 */
+__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;
+}
+
+
+__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 <>
+__host__ __device__
+inline complex<float> log(const complex<float>& z){
+  return detail::complex::clogf(z);
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/complex.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/complex.inl
new file mode 100644
index 0000000000000000000000000000000000000000..a00b81a4b01da0c99fc2d781b9f5550f23014062
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/complex.inl
@@ -0,0 +1,355 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/* --- Constructors --- */
+
+#if THRUST_CPP_DIALECT < 2011
+template <typename T>
+__host__ __device__
+complex<T>::complex()
+{
+  real(T());
+  imag(T());
+}
+#endif
+
+template <typename T>
+__host__ __device__
+complex<T>::complex(const T& re)
+#if THRUST_CPP_DIALECT >= 2011
+  // Initialize the storage in the member initializer list using C++ unicorn
+  // initialization. This allows `complex<T const>` to work.
+  : data{re, T()}
+{}
+#else
+{
+  real(re);
+  imag(T());
+}
+#endif
+
+
+template <typename T>
+__host__ __device__
+complex<T>::complex(const T& re, const T& im)
+#if THRUST_CPP_DIALECT >= 2011
+  // Initialize the storage in the member initializer list using C++ unicorn
+  // initialization. This allows `complex<T const>` to work.
+  : data{re, im}
+{}
+#else
+{
+  real(re);
+  imag(im);
+}
+#endif
+
+#if THRUST_CPP_DIALECT < 2011
+template <typename T>
+__host__ __device__
+complex<T>::complex(const complex<T>& z)
+{
+  real(z.real());
+  imag(z.imag());
+}
+#endif
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>::complex(const complex<U>& z)
+#if THRUST_CPP_DIALECT >= 2011
+  // Initialize the storage in the member initializer list using C++ unicorn
+  // initialization. This allows `complex<T const>` to work.
+  // We do a functional-style cast here to suppress conversion warnings.
+  : data{T(z.real()), T(z.imag())}
+{}
+#else
+{
+  real(T(z.real()));
+  imag(T(z.imag()));
+}
+#endif
+
+template <typename T>
+__host__ THRUST_STD_COMPLEX_DEVICE
+complex<T>::complex(const std::complex<T>& z)
+#if THRUST_CPP_DIALECT >= 2011
+  // Initialize the storage in the member initializer list using C++ unicorn
+  // initialization. This allows `complex<T const>` to work.
+  : data{THRUST_STD_COMPLEX_REAL(z), THRUST_STD_COMPLEX_IMAG(z)}
+{}
+#else
+{
+  real(THRUST_STD_COMPLEX_REAL(z));
+  imag(THRUST_STD_COMPLEX_IMAG(z));
+}
+#endif
+
+template <typename T>
+template <typename U>
+__host__ THRUST_STD_COMPLEX_DEVICE
+complex<T>::complex(const std::complex<U>& z)
+#if THRUST_CPP_DIALECT >= 2011
+  // Initialize the storage in the member initializer list using C++ unicorn
+  // initialization. This allows `complex<T const>` to work.
+  // We do a functional-style cast here to suppress conversion warnings.
+  : data{T(THRUST_STD_COMPLEX_REAL(z)), T(THRUST_STD_COMPLEX_IMAG(z))}
+{}
+#else
+{
+  real(T(THRUST_STD_COMPLEX_REAL(z)));
+  imag(T(THRUST_STD_COMPLEX_IMAG(z)));
+}
+#endif
+
+
+
+/* --- Assignment Operators --- */
+
+template <typename T>
+__host__ __device__
+complex<T>& complex<T>::operator=(const T& re)
+{
+  real(re);
+  imag(T());
+  return *this;
+}
+
+#if THRUST_CPP_DIALECT < 2011
+template <typename T>
+__host__ __device__
+complex<T>& complex<T>::operator=(const complex<T>& z)
+{
+  real(z.real());
+  imag(z.imag());
+  return *this;
+}
+#endif
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator=(const complex<U>& z)
+{
+  real(T(z.real()));
+  imag(T(z.imag()));
+  return *this;
+}
+
+template <typename T>
+__host__ THRUST_STD_COMPLEX_DEVICE
+complex<T>& complex<T>::operator=(const std::complex<T>& z)
+{
+  real(THRUST_STD_COMPLEX_REAL(z));
+  imag(THRUST_STD_COMPLEX_IMAG(z));
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ THRUST_STD_COMPLEX_DEVICE
+complex<T>& complex<T>::operator=(const std::complex<U>& z)
+{
+  real(T(THRUST_STD_COMPLEX_REAL(z)));
+  imag(T(THRUST_STD_COMPLEX_IMAG(z)));
+  return *this;
+}
+
+
+
+/* --- Compound Assignment Operators --- */
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator+=(const complex<U>& z)
+{
+  *this = *this + z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator-=(const complex<U>& z)
+{
+  *this = *this - z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator*=(const complex<U>& z)
+{
+  *this = *this * z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator/=(const complex<U>& z)
+{
+  *this = *this / z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator+=(const U& z)
+{
+  *this = *this + z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator-=(const U& z)
+{
+  *this = *this - z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator*=(const U& z)
+{
+  *this = *this * z;
+  return *this;
+}
+
+template <typename T>
+template <typename U>
+__host__ __device__
+complex<T>& complex<T>::operator/=(const U& z)
+{
+  *this = *this / z;
+  return *this;
+}
+
+
+
+/* --- Equality Operators --- */
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const complex<T0>& x, const complex<T1>& y)
+{
+  return x.real() == y.real() && x.imag() == y.imag();
+}
+
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator==(const complex<T0>& x, const std::complex<T1>& y)
+{
+  return x.real() == THRUST_STD_COMPLEX_REAL(y) && x.imag() == THRUST_STD_COMPLEX_IMAG(y);
+}
+
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator==(const std::complex<T0>& x, const complex<T1>& y)
+{
+  return THRUST_STD_COMPLEX_REAL(x) == y.real() && THRUST_STD_COMPLEX_IMAG(x) == y.imag();
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const T0& x, const complex<T1>& y)
+{
+  return x == y.real() && y.imag() == T1();
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator==(const complex<T0>& x, const T1& y)
+{
+  return x.real() == y && x.imag() == T1();
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const complex<T0>& x, const complex<T1>& y)
+{
+  return !(x == y);
+}
+
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator!=(const complex<T0>& x, const std::complex<T1>& y)
+{
+  return !(x == y);
+}
+
+template <typename T0, typename T1>
+__host__ THRUST_STD_COMPLEX_DEVICE
+bool operator!=(const std::complex<T0>& x, const complex<T1>& y)
+{
+  return !(x == y);
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const T0& x, const complex<T1>& y)
+{
+  return !(x == y);
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+bool operator!=(const complex<T0>& x, const T1& y)
+{
+  return !(x == y);
+}
+
+template <typename T>
+struct proclaim_trivially_relocatable<complex<T> > : thrust::true_type {};
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/complex/arithmetic.h>
+#include <thrust/detail/complex/cproj.h>
+#include <thrust/detail/complex/cexp.h>
+#include <thrust/detail/complex/cexpf.h>
+#include <thrust/detail/complex/clog.h>
+#include <thrust/detail/complex/clogf.h>
+#include <thrust/detail/complex/cpow.h>
+#include <thrust/detail/complex/ccosh.h>
+#include <thrust/detail/complex/ccoshf.h>
+#include <thrust/detail/complex/csinh.h>
+#include <thrust/detail/complex/csinhf.h>
+#include <thrust/detail/complex/ctanh.h>
+#include <thrust/detail/complex/ctanhf.h>
+#include <thrust/detail/complex/csqrt.h>
+#include <thrust/detail/complex/csqrtf.h>
+#include <thrust/detail/complex/catrig.h>
+#include <thrust/detail/complex/catrigf.h>
+#include <thrust/detail/complex/stream.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cpow.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cpow.h
new file mode 100644
index 0000000000000000000000000000000000000000..c204c451fff981a48f733d5ae55943270631ae4b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cpow.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const complex<T0>& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return exp(log(complex<T>(x)) * complex<T>(y));
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const complex<T0>& x, const T1& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  return exp(log(complex<T>(x)) * T(y));
+}
+
+template <typename T0, typename T1>
+__host__ __device__
+complex<typename detail::promoted_numerical_type<T0, T1>::type>
+pow(const T0& x, const complex<T1>& y)
+{
+  typedef typename detail::promoted_numerical_type<T0, T1>::type T;
+  // Find `log` by ADL.
+  using std::log;
+  return exp(log(T(x)) * complex<T>(y));
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cproj.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cproj.h
new file mode 100644
index 0000000000000000000000000000000000000000..7537c99fd75ea39195cf8e7d68fb6b5d7f21c3ba
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/cproj.h
@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *  Copyright 2013 Filipe RNC Maia
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+#include <thrust/detail/complex/math_private.h>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{	 
+__host__ __device__
+inline complex<float> cprojf(const complex<float>& z){
+  if(!isinf(z.real()) && !isinf(z.imag())){
+    return z;
+  }else{
+    // std::numeric_limits<T>::infinity() doesn't run on the GPU
+    return complex<float>(infinity<float>(), copysignf(0.0, z.imag()));
+  }
+}
+  
+__host__ __device__
+inline complex<double> cproj(const complex<double>& z){
+  if(!isinf(z.real()) && !isinf(z.imag())){
+    return z;
+  }else{
+    // std::numeric_limits<T>::infinity() doesn't run on the GPU
+    return complex<double>(infinity<double>(), copysign(0.0, z.imag()));
+  }
+}
+
+}
+ 
+}
+
+template <typename T>
+__host__ __device__
+inline thrust::complex<T> proj(const thrust::complex<T>& z){
+  return detail::complex::cproj(z);
+}
+  
+
+template <>
+__host__ __device__
+inline thrust::complex<double> proj(const thrust::complex<double>& z){
+  return detail::complex::cproj(z);
+}
+  
+template <>
+__host__ __device__
+inline thrust::complex<float> proj(const thrust::complex<float>& z){
+  return detail::complex::cprojf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinh.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinh.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5a22af01e6b345d46fa723a498e4f10770879a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinh.h
@@ -0,0 +1,207 @@
+/*
+ *  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/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{		      	
+
+using thrust::complex;
+
+__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)));
+}
+
+__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>
+__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>
+__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 <>
+__host__ __device__
+inline complex<double> sin(const complex<double>& z){
+  return detail::complex::csin(z);
+}
+
+template <>
+__host__ __device__
+inline complex<double> sinh(const complex<double>& z){
+  return detail::complex::csinh(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinhf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinhf.h
new file mode 100644
index 0000000000000000000000000000000000000000..d271081c65473e8e59caed95c4575d22114e1c88
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csinhf.h
@@ -0,0 +1,144 @@
+/*
+ *  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/math_private.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{		      	
+
+using thrust::complex;
+
+__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)));
+}
+
+__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 <>
+__host__ __device__
+inline complex<float> sin(const complex<float>& z){
+  return detail::complex::csinf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> sinh(const complex<float>& z){
+  return detail::complex::csinhf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrt.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrt.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb4da5289f83175b4a62f54fe618fa3534f889b0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrt.h
@@ -0,0 +1,154 @@
+/*
+ *  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) 2007 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 by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/s_csqrt.c
+ */
+
+
+#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;
+
+__host__ __device__ inline
+complex<double> csqrt(const complex<double>& z){
+  complex<double> result;
+  double a, b;
+  double t;
+  int scale;
+
+  /* We risk spurious overflow for components >= DBL_MAX / (1 + sqrt(2)). */
+  const double THRESH = 7.446288774449766337959726e+307;
+
+  a = z.real();
+  b = z.imag();
+
+  /* Handle special cases. */
+  if (z == 0.0)
+    return (complex<double>(0.0, b));
+  if (isinf(b))
+    return (complex<double>(infinity<double>(), b));
+  if (isnan(a)) {
+    t = (b - b) / (b - b);	/* raise invalid if b is not a NaN */
+    return (complex<double>(a, t));	/* return NaN + NaN i */
+  }
+  if (isinf(a)) {
+    /*
+     * csqrt(inf + NaN i)  = inf +  NaN i
+     * csqrt(inf + y i)    = inf +  0 i
+     * csqrt(-inf + NaN i) = NaN +- inf i
+     * csqrt(-inf + y i)   = 0   +  inf i
+     */
+    if (signbit(a))
+      return (complex<double>(fabs(b - b), copysign(a, b)));
+    else
+      return (complex<double>(a, copysign(b - b, b)));
+  }
+  /*
+   * The remaining special case (b is NaN) is handled just fine by
+   * the normal code path below.
+   */
+
+  // DBL_MIN*2
+  const double low_thresh = 4.450147717014402766180465e-308;
+  scale = 0;
+
+  if (fabs(a) >= THRESH || fabs(b) >= THRESH) {
+    /* Scale to avoid overflow. */
+    a *= 0.25;
+    b *= 0.25;
+    scale = 1;
+  }else if (fabs(a) <= low_thresh && fabs(b) <= low_thresh) {
+    /* Scale to avoid underflow. */
+    a *= 4.0;
+    b *= 4.0;
+    scale = 2;
+  }
+	
+
+  /* Algorithm 312, CACM vol 10, Oct 1967. */
+  if (a >= 0.0) {
+    t = sqrt((a + hypot(a, b)) * 0.5);
+    result = complex<double>(t, b / (2 * t));
+  } else {
+    t = sqrt((-a + hypot(a, b)) * 0.5);
+    result = complex<double>(fabs(b) / (2 * t), copysign(t, b));
+  }
+
+  /* Rescale. */
+  if (scale == 1)
+    return (result * 2.0);
+  else if (scale == 2)
+    return (result * 0.5);
+  else
+    return (result);
+}
+      
+} // namespace complex
+
+} // namespace detail
+
+template <typename ValueType>
+__host__ __device__
+inline complex<ValueType> sqrt(const complex<ValueType>& z){
+  return thrust::polar(std::sqrt(thrust::abs(z)),thrust::arg(z)/ValueType(2));
+}
+
+template <>
+__host__ __device__
+inline complex<double> sqrt(const complex<double>& z){
+  return detail::complex::csqrt(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrtf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrtf.h
new file mode 100644
index 0000000000000000000000000000000000000000..dba489a33a89a056c84c70a77b79ceb0a717f4cf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/csqrtf.h
@@ -0,0 +1,149 @@
+/*
+ *  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) 2007 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 by Filipe Maia <filipe.c.maia@gmail.com>:
+ *    freebsd/lib/msun/src/s_csqrt.c
+ */
+
+
+#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;
+
+__host__ __device__ inline
+complex<float> csqrtf(const complex<float>& z){
+  float a = z.real(), b = z.imag();
+  float t;
+  int scale;
+  complex<float> result;
+
+  /* We risk spurious overflow for components >= FLT_MAX / (1 + sqrt(2)). */
+  const float THRESH = 1.40949553037932e+38f;
+
+  /* Handle special cases. */
+  if (z == 0.0f)
+    return (complex<float>(0, b));
+  if (isinf(b))
+    return (complex<float>(infinity<float>(), b));
+  if (isnan(a)) {
+    t = (b - b) / (b - b);	/* raise invalid if b is not a NaN */
+    return (complex<float>(a, t));	/* return NaN + NaN i */
+  }
+  if (isinf(a)) {
+    /*
+     * csqrtf(inf + NaN i)  = inf +  NaN i
+     * csqrtf(inf + y i)    = inf +  0 i
+     * csqrtf(-inf + NaN i) = NaN +- inf i
+     * csqrtf(-inf + y i)   = 0   +  inf i
+     */
+    if (signbit(a))
+      return (complex<float>(fabsf(b - b), copysignf(a, b)));
+    else
+      return (complex<float>(a, copysignf(b - b, b)));
+  }
+  /*
+   * The remaining special case (b is NaN) is handled just fine by
+   * the normal code path below.
+   */
+
+  /* 
+   * Unlike in the FreeBSD code we'll avoid using double precision as
+   * not all hardware supports it.
+   */
+
+  // FLT_MIN*2
+  const float low_thresh = 2.35098870164458e-38f;
+  scale = 0;
+
+  if (fabsf(a) >= THRESH || fabsf(b) >= THRESH) {
+    /* Scale to avoid overflow. */
+    a *= 0.25f;
+    b *= 0.25f;
+    scale = 1;
+  }else if (fabsf(a) <= low_thresh && fabsf(b) <= low_thresh) {
+    /* Scale to avoid underflow. */
+    a *= 4.f;
+    b *= 4.f;
+    scale = 2;
+  }
+
+  /* Algorithm 312, CACM vol 10, Oct 1967. */
+  if (a >= 0.0f) {
+    t = sqrtf((a + hypotf(a, b)) * 0.5f);
+    result = complex<float>(t, b / (2.0f * t));
+  } else {
+    t = sqrtf((-a + hypotf(a, b)) * 0.5f);
+    result = complex<float>(fabsf(b) / (2.0f * t), copysignf(t, b));
+  }
+
+  /* Rescale. */
+  if (scale == 1)
+    return (result * 2.0f);
+  else if (scale == 2)
+    return (result * 0.5f);
+  else
+    return (result);
+}      
+
+} // namespace complex
+
+} // namespace detail
+
+template <>
+__host__ __device__
+inline complex<float> sqrt(const complex<float>& z){
+  return detail::complex::csqrtf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanh.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanh.h
new file mode 100644
index 0000000000000000000000000000000000000000..3275c0343cb78c9a7b9ca619fee89d6fc49a514c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanh.h
@@ -0,0 +1,202 @@
+/*
+ *  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;
+
+__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));
+}
+
+__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>
+__host__ __device__
+inline complex<ValueType> tan(const complex<ValueType>& z){
+  return sin(z)/cos(z);
+}
+
+template <typename ValueType>
+__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 <>
+__host__ __device__
+inline complex<double> tan(const complex<double>& z){
+  return detail::complex::ctan(z);
+}
+  
+template <>
+__host__ __device__
+inline complex<double> tanh(const complex<double>& z){
+  return detail::complex::ctanh(z);
+}
+  
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanhf.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanhf.h
new file mode 100644
index 0000000000000000000000000000000000000000..221b5ce47cb0a78cdb22d3ef56e93ddb6702cbe8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/ctanhf.h
@@ -0,0 +1,126 @@
+/*
+ *  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;
+
+__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));
+}
+
+  __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 <>
+__host__ __device__
+inline complex<float> tan(const complex<float>& z){
+  return detail::complex::ctanf(z);
+}
+
+template <>
+__host__ __device__
+inline complex<float> tanh(const complex<float>& z){
+  return detail::complex::ctanhf(z);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/math_private.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/math_private.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a40c8e72918a310e9559d32b8a998c8b7be73fc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/math_private.h
@@ -0,0 +1,136 @@
+/*
+ *  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) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/* adapted from FreeBSD:
+ *    lib/msun/src/math_private.h
+ */
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/complex.h>
+#include <thrust/detail/cstdint.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail{
+namespace complex{
+
+using thrust::complex;
+
+typedef union
+{
+  float value;
+  uint32_t word;
+} ieee_float_shape_type;
+  
+__host__ __device__
+inline void get_float_word(uint32_t & i, float d){
+  ieee_float_shape_type gf_u;
+  gf_u.value = (d);
+  (i) = gf_u.word;
+}
+
+__host__ __device__
+inline void get_float_word(int32_t & i, float d){
+  ieee_float_shape_type gf_u;
+  gf_u.value = (d);
+  (i) = gf_u.word;
+}
+
+__host__ __device__
+inline void set_float_word(float & d, uint32_t i){
+  ieee_float_shape_type sf_u;
+  sf_u.word = (i);
+  (d) = sf_u.value;
+}
+
+// Assumes little endian ordering
+typedef union
+{
+  double value;
+  struct
+  {
+    uint32_t lsw;
+    uint32_t msw;
+  } parts;
+  struct
+  {
+    uint64_t w;
+  } xparts;
+} ieee_double_shape_type;
+  
+__host__ __device__ inline
+void get_high_word(uint32_t & i,double d){
+  ieee_double_shape_type gh_u;
+  gh_u.value = (d);
+  (i) = gh_u.parts.msw;                                   
+}
+  
+/* Set the more significant 32 bits of a double from an int.  */
+__host__ __device__ inline
+void set_high_word(double & d, uint32_t v){
+  ieee_double_shape_type sh_u;
+  sh_u.value = (d);
+  sh_u.parts.msw = (v);
+  (d) = sh_u.value;
+}
+  
+  
+__host__ __device__ inline 
+void  insert_words(double & d, uint32_t ix0, uint32_t ix1){
+  ieee_double_shape_type iw_u;
+  iw_u.parts.msw = (ix0);
+  iw_u.parts.lsw = (ix1);
+  (d) = iw_u.value;
+}
+  
+/* Get two 32 bit ints from a double.  */
+__host__ __device__ inline
+void  extract_words(uint32_t & ix0,uint32_t & ix1, double d){
+  ieee_double_shape_type ew_u;
+  ew_u.value = (d);
+  (ix0) = ew_u.parts.msw;
+  (ix1) = ew_u.parts.lsw;
+}
+  
+/* Get two 32 bit ints from a double.  */
+__host__ __device__ inline
+void  extract_words(int32_t & ix0,int32_t & ix1, double d){
+  ieee_double_shape_type ew_u;
+  ew_u.value = (d);
+  (ix0) = ew_u.parts.msw;
+  (ix1) = ew_u.parts.lsw;
+}
+  
+} // namespace complex
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+
+#include <thrust/detail/complex/c99math.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/stream.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..95434b41beb7af923324ac2f6aec5346c76fc5c6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/complex/stream.h
@@ -0,0 +1,74 @@
+/*
+ *  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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/complex.h>
+
+THRUST_NAMESPACE_BEGIN
+template<typename ValueType,class charT, class traits>
+std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& os, const complex<ValueType>& z)
+{
+  os << '(' << z.real() << ',' << z.imag() << ')';
+  return os;
+}
+
+template<typename ValueType, typename charT, class traits>
+std::basic_istream<charT, traits>&
+operator>>(std::basic_istream<charT, traits>& is, complex<ValueType>& z)
+{
+  ValueType re, im;
+
+  charT ch;
+  is >> ch;
+
+  if(ch == '(')
+    {
+      is >> re >> ch;
+      if (ch == ',')
+        {
+          is >> im >> ch;
+          if (ch == ')')
+	    {
+	      z = complex<ValueType>(re, im);
+	    }
+          else
+	    {
+	      is.setstate(std::ios_base::failbit);
+	    }
+        }
+      else if (ch == ')')
+        {
+          z = re;
+        }
+      else
+        {
+          is.setstate(std::ios_base::failbit);
+        }
+    }
+  else
+    {
+      is.putback(ch);
+      is >> re;
+      z = re;
+    }
+  return is;
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a5573a410e6ee8ec7b062ee4bd330390fb37e9b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config.h
@@ -0,0 +1,24 @@
+/*
+ *  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/version.h>
+#include <thrust/detail/config/config.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..e35652f6a41f93c13b69b5980a78fb4a2d49c4da
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler.h
@@ -0,0 +1,189 @@
+/*
+ *  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
+
+// enumerate host compilers we know about
+#define THRUST_HOST_COMPILER_UNKNOWN 0
+#define THRUST_HOST_COMPILER_MSVC    1
+#define THRUST_HOST_COMPILER_GCC     2
+#define THRUST_HOST_COMPILER_CLANG   3
+#define THRUST_HOST_COMPILER_INTEL   4
+
+// enumerate device compilers we know about
+#define THRUST_DEVICE_COMPILER_UNKNOWN 0
+#define THRUST_DEVICE_COMPILER_MSVC    1
+#define THRUST_DEVICE_COMPILER_GCC     2
+#define THRUST_DEVICE_COMPILER_CLANG   3
+#define THRUST_DEVICE_COMPILER_NVCC    4
+
+// figure out which host compiler we're using
+// XXX we should move the definition of THRUST_DEPRECATED out of this logic
+#if   defined(_MSC_VER)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_MSVC
+#define THRUST_MSVC_VERSION _MSC_VER
+#define THRUST_MSVC_VERSION_FULL _MSC_FULL_VER
+#elif defined(__ICC)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_INTEL
+#elif defined(__clang__)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_CLANG
+#define THRUST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#elif defined(__GNUC__)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_GCC
+#define THRUST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#if (THRUST_GCC_VERSION >= 50000)
+#define THRUST_MODERN_GCC
+#else
+#define THRUST_LEGACY_GCC
+#endif
+#else
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_UNKNOWN
+#endif // THRUST_HOST_COMPILER
+
+// figure out which device compiler we're using
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_MSVC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_GCC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+// CUDA-capable clang should behave similar to NVCC.
+#if defined(__CUDA__)
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#else
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_CLANG
+#endif
+#else
+#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
+
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && !defined(__CUDA_ARCH__)
+  #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x)                                \
+    __pragma(warning(push))                                                   \
+    __pragma(warning(disable : x))                                            \
+    /**/
+  #define THRUST_DISABLE_MSVC_WARNING_END(x)                                  \
+    __pragma(warning(pop))                                                    \
+    /**/
+#else
+  #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_MSVC_WARNING_END(x)
+#endif
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG) && !defined(__CUDA_ARCH__)
+  #define THRUST_IGNORE_CLANG_WARNING_IMPL(x)                                 \
+    THRUST_PP_STRINGIZE(clang diagnostic ignored x)                           \
+    /**/
+  #define THRUST_IGNORE_CLANG_WARNING(x)                                      \
+    THRUST_IGNORE_CLANG_WARNING_IMPL(THRUST_PP_STRINGIZE(x))                  \
+    /**/
+
+  #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x)                               \
+    _Pragma("clang diagnostic push")                                          \
+    _Pragma(THRUST_IGNORE_CLANG_WARNING(x))                                   \
+    /**/
+  #define THRUST_DISABLE_CLANG_WARNING_END(x)                                 \
+    _Pragma("clang diagnostic pop")                                           \
+    /**/
+#else
+  #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_CLANG_WARNING_END(x)
+#endif
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && !defined(__CUDA_ARCH__)
+  #define THRUST_IGNORE_GCC_WARNING_IMPL(x)                                   \
+    THRUST_PP_STRINGIZE(GCC diagnostic ignored x)                             \
+    /**/
+  #define THRUST_IGNORE_GCC_WARNING(x)                                        \
+    THRUST_IGNORE_GCC_WARNING_IMPL(THRUST_PP_STRINGIZE(x))                    \
+    /**/
+
+  #define THRUST_DISABLE_GCC_WARNING_BEGIN(x)                                 \
+    _Pragma("GCC diagnostic push")                                            \
+    _Pragma(THRUST_IGNORE_GCC_WARNING(x))                                     \
+    /**/
+  #define THRUST_DISABLE_GCC_WARNING_END(x)                                   \
+    _Pragma("GCC diagnostic pop")                                             \
+    /**/
+#else
+  #define THRUST_DISABLE_GCC_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_GCC_WARNING_END(x)
+#endif
+
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN               \
+  THRUST_DISABLE_MSVC_WARNING_BEGIN(4244 4267)                                \
+  /**/
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END                 \
+  THRUST_DISABLE_MSVC_WARNING_END(4244 4267)                                  \
+  /**/
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING(x)                  \
+  THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN                     \
+  x;                                                                          \
+  THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END                       \
+  /**/
+
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN               \
+  THRUST_DISABLE_MSVC_WARNING_BEGIN(4800)                                     \
+  /**/
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END                 \
+  THRUST_DISABLE_MSVC_WARNING_END(4800)                                       \
+  /**/
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING(x)                  \
+  THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN                     \
+  x;                                                                          \
+  THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END                       \
+  /**/
+
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN                    \
+  THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wself-assign)                           \
+  /**/
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END                      \
+  THRUST_DISABLE_CLANG_WARNING_END(-Wself-assign)                             \
+  /**/
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING(x)                       \
+  THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN                          \
+  x;                                                                          \
+  THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END                            \
+  /**/
+
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN     \
+  THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wreorder)                               \
+  THRUST_DISABLE_GCC_WARNING_BEGIN(-Wreorder)                                 \
+  /**/
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END       \
+  THRUST_DISABLE_CLANG_WARNING_END(-Wreorder)                                 \
+  THRUST_DISABLE_GCC_WARNING_END(-Wreorder)                                   \
+  /**/
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING(x)        \
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN           \
+  x;                                                                          \
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END             \
+  /**/
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler_fence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler_fence.h
new file mode 100644
index 0000000000000000000000000000000000000000..c379abaf364b460031a93a0ad6d4ee3d8419ab78
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/compiler_fence.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>
+#include <thrust/detail/preprocessor.h>
+
+// TODO: Enable this or remove this file once nvGRAPH/CUSP migrates off of it.
+//#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+//  #pragma message("warning: The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 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 THRUST_HOST_COMPILER == THRUST_HOST_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 THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+
+#if THRUST_GCC_VERSION >= 40200 // 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 // THRUST_GCC_VERSION
+
+// unknown case
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+#define __thrust_compiler_fence() __sync_synchronize()
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_UNKNOWN
+
+// allow the code to compile without any guarantees
+#define __thrust_compiler_fence() do {} while (0)
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/config.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..797f6605b082bc5f186a8b31708aeb01e3257334
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/config.h
@@ -0,0 +1,40 @@
+/*
+ *  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
+
+// NOTE: The order of these #includes matters.
+
+#include <thrust/detail/config/simple_defines.h>
+#include <thrust/detail/config/compiler.h>
+#include <thrust/detail/config/cpp_dialect.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+#include <thrust/detail/config/deprecated.h>
+// 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>
+#include <thrust/detail/config/device_system.h>
+#include <thrust/detail/config/host_device.h>
+#include <thrust/detail/config/debug.h>
+#include <thrust/detail/config/forceinline.h>
+#include <thrust/detail/config/exec_check_disable.h>
+#include <thrust/detail/config/global_workarounds.h>
+#include <thrust/detail/config/namespace.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_compatibility.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_compatibility.h
new file mode 100644
index 0000000000000000000000000000000000000000..18b9cbdcf59928bf383012fb3e785416adb37d15
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_compatibility.h
@@ -0,0 +1,101 @@
+/*
+ *  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/cpp_dialect.h>
+
+#include <cstddef>
+
+#ifndef __has_cpp_attribute
+#  define __has_cpp_attribute(X) 0
+#endif
+
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+#  define THRUST_TRAILING_RETURN(...)
+#else
+#  define THRUST_TRAILING_RETURN(...) -> __VA_ARGS__
+#endif
+
+#if THRUST_CPP_DIALECT >= 2014 && __has_cpp_attribute(nodiscard)
+#  define THRUST_NODISCARD [[nodiscard]]
+#else
+#  define THRUST_NODISCARD
+#endif
+
+#if THRUST_CPP_DIALECT >= 2017 && __cpp_if_constexpr
+#  define THRUST_IF_CONSTEXPR if constexpr
+#else
+#  define THRUST_IF_CONSTEXPR if
+#endif
+
+// FIXME: Combine THRUST_INLINE_CONSTANT and
+// THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT into one macro when NVCC properly
+// supports `constexpr` globals in host and device code.
+#if defined(__CUDA_ARCH__) || defined(_NVHPC_CUDA)
+// FIXME: Add this when NVCC supports inline variables.
+//#  if   THRUST_CPP_DIALECT >= 2017
+//#    define THRUST_INLINE_CONSTANT                 inline constexpr
+//#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr
+#  if THRUST_CPP_DIALECT >= 2011
+#    define THRUST_INLINE_CONSTANT                 static const __device__
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+#  else
+#    define THRUST_INLINE_CONSTANT                 static const __device__
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const
+#  endif
+#else
+// FIXME: Add this when NVCC supports inline variables.
+//#  if   THRUST_CPP_DIALECT >= 2017
+//#    define THRUST_INLINE_CONSTANT                 inline constexpr
+//#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr
+#  if THRUST_CPP_DIALECT >= 2011
+#    define THRUST_INLINE_CONSTANT                 static constexpr
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+#  else
+#    define THRUST_INLINE_CONSTANT                 static const
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const
+#  endif
+#endif
+
+// 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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_dialect.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_dialect.h
new file mode 100644
index 0000000000000000000000000000000000000000..46b0caec78032efb3d450722a411c678060d9206
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/cpp_dialect.h
@@ -0,0 +1,140 @@
+/*
+ *  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/compiler.h>
+
+// Deprecation warnings may be silenced by defining the following macros. These
+// may be combined.
+// - THRUST_IGNORE_DEPRECATED_CPP_DIALECT:
+//   Ignore all deprecated C++ dialects and outdated compilers.
+// - THRUST_IGNORE_DEPRECATED_CPP_11:
+//   Ignore deprecation warnings when compiling with C++11. C++03 and outdated
+//   compilers will still issue warnings.
+// - THRUST_IGNORE_DEPRECATED_COMPILER
+//   Ignore deprecation warnings when using deprecated compilers. Compiling
+//   with C++03 and C++11 will still issue warnings.
+
+// Check for the CUB opt-outs as well:
+#if !defined(THRUST_IGNORE_DEPRECATED_CPP_DIALECT) && \
+     defined(CUB_IGNORE_DEPRECATED_CPP_DIALECT)
+#  define    THRUST_IGNORE_DEPRECATED_CPP_DIALECT
+#endif
+#if !defined(THRUST_IGNORE_DEPRECATED_CPP_11) && \
+     defined(CUB_IGNORE_DEPRECATED_CPP_11)
+#  define    THRUST_IGNORE_DEPRECATED_CPP_11
+#endif
+#if !defined(THRUST_IGNORE_DEPRECATED_COMPILER) && \
+     defined(CUB_IGNORE_DEPRECATED_COMPILER)
+#  define    THRUST_IGNORE_DEPRECATED_COMPILER
+#endif
+
+#ifdef THRUST_IGNORE_DEPRECATED_CPP_DIALECT
+#  define THRUST_IGNORE_DEPRECATED_CPP_11
+#  define THRUST_IGNORE_DEPRECATED_COMPILER
+#endif
+
+// Define this to override the built-in detection.
+#ifndef THRUST_CPP_DIALECT
+
+// MSVC does not define __cplusplus correctly. _MSVC_LANG is used instead.
+// This macro is only defined in MSVC 2015U3+.
+#  ifdef _MSVC_LANG // Do not replace with THRUST_HOST_COMPILER test (see above)
+// MSVC2015 reports C++14 but lacks extended constexpr support. Treat as C++11.
+#    if THRUST_MSVC_VERSION < 1910 && _MSVC_LANG > 201103L /* MSVC < 2017 && CPP > 2011 */
+#      define THRUST_CPLUSPLUS 201103L /* Fix to 2011 */
+#    else
+#      define THRUST_CPLUSPLUS _MSVC_LANG /* We'll trust this for now. */
+#    endif // MSVC 2015 C++14 fix
+#  else
+#    define THRUST_CPLUSPLUS __cplusplus
+#  endif
+
+// Detect current dialect:
+#  if THRUST_CPLUSPLUS < 201103L
+#    define THRUST_CPP_DIALECT 2003
+#  elif THRUST_CPLUSPLUS < 201402L
+#    define THRUST_CPP_DIALECT 2011
+#  elif THRUST_CPLUSPLUS < 201703L
+#    define THRUST_CPP_DIALECT 2014
+#  elif THRUST_CPLUSPLUS == 201703L
+#    define THRUST_CPP_DIALECT 2017
+#  elif THRUST_CPLUSPLUS > 201703L // unknown, but is higher than 2017.
+#    define THRUST_CPP_DIALECT 2020
+#  endif
+
+#  undef THRUST_CPLUSPLUS // cleanup
+
+#endif // !THRUST_CPP_DIALECT
+
+// Define THRUST_COMPILER_DEPRECATION macro:
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#  define THRUST_COMP_DEPR_IMPL(msg) \
+    __pragma(message(__FILE__ ":" THRUST_COMP_DEPR_IMPL0(__LINE__) ": warning: " #msg))
+#  define THRUST_COMP_DEPR_IMPL0(x) THRUST_COMP_DEPR_IMPL1(x)
+#  define THRUST_COMP_DEPR_IMPL1(x) #x
+#else // clang / gcc:
+#  define THRUST_COMP_DEPR_IMPL(msg) THRUST_COMP_DEPR_IMPL0(GCC warning #msg)
+#  define THRUST_COMP_DEPR_IMPL0(expr) _Pragma(#expr)
+#  define THRUST_COMP_DEPR_IMPL1 /* intentionally blank */
+#endif
+
+#define THRUST_COMPILER_DEPRECATION(REQ) \
+  THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. Define THRUST_IGNORE_DEPRECATED_CPP_DIALECT 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 THRUST_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.)
+
+#ifndef THRUST_IGNORE_DEPRECATED_COMPILER
+
+// Compiler checks:
+#  if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC && THRUST_GCC_VERSION < 50000
+     THRUST_COMPILER_DEPRECATION(GCC 5.0);
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG && THRUST_CLANG_VERSION < 70000
+     THRUST_COMPILER_DEPRECATION(Clang 7.0);
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1910
+     // <2017. Hard upgrade message:
+     THRUST_COMPILER_DEPRECATION(MSVC 2019 (19.20/16.0/14.20));
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1920
+     // >=2017, <2019. Soft deprecation message:
+     THRUST_COMPILER_DEPRECATION_SOFT(MSVC 2019 (19.20/16.0/14.20), MSVC 2017);
+#  endif
+
+#endif // THRUST_IGNORE_DEPRECATED_COMPILER
+
+#ifndef THRUST_IGNORE_DEPRECATED_DIALECT
+
+// Dialect checks:
+#  if THRUST_CPP_DIALECT < 2011
+     // <C++11. Hard upgrade message:
+     THRUST_COMPILER_DEPRECATION(C++14);
+#  elif THRUST_CPP_DIALECT == 2011 && !defined(THRUST_IGNORE_DEPRECATED_CPP_11)
+     // =C++11. Soft upgrade message:
+     THRUST_COMPILER_DEPRECATION_SOFT(C++14, C++11);
+#  endif
+
+#endif // THRUST_IGNORE_DEPRECATED_DIALECT
+
+#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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/debug.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/debug.h
new file mode 100644
index 0000000000000000000000000000000000000000..16f65d67c9054f4a32a6c7a4e437b1cdb16a6c30
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/debug.h
@@ -0,0 +1,32 @@
+/*
+ *  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
+
+#ifndef THRUST_DEBUG
+#  ifndef NDEBUG
+#    if defined(DEBUG) || defined(_DEBUG)
+#      define THRUST_DEBUG 1
+#    endif // (DEBUG || _DEBUG)
+#  endif // NDEBUG
+#endif // THRUST_DEBUG
+
+#if THRUST_DEBUG
+#  ifndef __THRUST_SYNCHRONOUS
+#    define __THRUST_SYNCHRONOUS 1
+#  endif // __THRUST_SYNCHRONOUS
+#endif // THRUST_DEBUG
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/deprecated.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/deprecated.h
new file mode 100644
index 0000000000000000000000000000000000000000..05851c6768fcaba996bf50764104f61821dec4d8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/deprecated.h
@@ -0,0 +1,42 @@
+/*
+ *  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.
+ */
+
+/*! \file deprecated.h
+ *  \brief Defines the THRUST_DEPRECATED macro
+ */
+
+#pragma once
+
+#include <thrust/detail/config/compiler.h>
+#include <thrust/detail/config/cpp_dialect.h>
+
+#if defined(CUB_IGNORE_DEPRECATED_API) && !defined(THRUST_IGNORE_DEPRECATED_API)
+#  define THRUST_IGNORE_DEPRECATED_API
+#endif
+
+#ifdef THRUST_IGNORE_DEPRECATED_API
+#  define THRUST_DEPRECATED
+#elif THRUST_CPP_DIALECT >= 2014
+#  define THRUST_DEPRECATED [[deprecated]]
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#  define THRUST_DEPRECATED __declspec(deprecated)
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+#  define THRUST_DEPRECATED __attribute__((deprecated))
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+#  define THRUST_DEPRECATED __attribute__((deprecated))
+#else
+#  define THRUST_DEPRECATED
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/device_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/device_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..29418c90308a6f6cd6a506ea0f344ab9d27369da
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/device_system.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// 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
+
+#define __THRUST_DEVICE_SYSTEM_ROOT thrust/system/__THRUST_DEVICE_SYSTEM_NAMESPACE
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/exec_check_disable.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/exec_check_disable.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b25b375dfbfb572c25922e4e9b26a8bea032597
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/exec_check_disable.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 exec_check_disable.h
+ *  \brief Defines __thrust_exec_check_disable__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #pragma nv_exec_check_disable is only recognized by NVCC.  Having a macro
+// expand to a #pragma (rather than _Pragma) only works with NVCC's compilation
+// model, not with other compilers.
+#if defined(__CUDACC__) && !defined(_NVHPC_CUDA) && \
+    !(defined(__CUDA__) && defined(__clang__))
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#define __thrust_exec_check_disable__ __pragma("nv_exec_check_disable")
+#else // MSVC
+#define __thrust_exec_check_disable__ _Pragma("nv_exec_check_disable")
+#endif // MSVC
+
+#else
+
+#define __thrust_exec_check_disable__
+
+#endif
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/forceinline.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/forceinline.h
new file mode 100644
index 0000000000000000000000000000000000000000..b001fd4b1148b6d77f99cad072c4c53fcbf7b033
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/forceinline.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.
+ */
+
+/*! \file forceinline.h
+ *  \brief Defines __thrust_forceinline__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+
+#define __thrust_forceinline__ __forceinline__
+
+#else
+
+// TODO add 
+
+#define __thrust_forceinline__
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/global_workarounds.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/global_workarounds.h
new file mode 100644
index 0000000000000000000000000000000000000000..9800f03593ac253914c149815a497bf01baee4b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/global_workarounds.h
@@ -0,0 +1,27 @@
+/*
+ *  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/compiler.h>
+
+// XXX workaround gcc 4.8+'s complaints about unused local typedefs by silencing them globally
+#if defined(THRUST_GCC_VERSION) && (THRUST_GCC_VERSION >= 40800)
+#  if defined(__NVCC__) && (CUDART_VERSION >= 6000)
+#    pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#  endif // nvcc & cuda 6+
+#endif // gcc 4.8
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..5540f91260d807bfb2ef06064767aeaccea2fc1a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_device.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file host_device.h
+ *  \brief Defines __host__ and __device__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// since nvcc defines __host__ and __device__ for us,
+// and only nvcc knows what to do with __host__ and __device__,
+// define them to be the empty string for other compilers
+
+#if THRUST_DEVICE_COMPILER != THRUST_DEVICE_COMPILER_NVCC
+
+// since __host__ & __device__ might have already be defined, only
+// #define them if not defined already
+// XXX this will break if the client does #include <host_defines.h> later
+
+#ifndef __host__
+#define __host__
+#endif // __host__
+
+#ifndef __device__
+#define __device__
+#endif // __device__
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..f216f649237bd7f823f8fe744b72005511bc48f9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/host_system.h
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// 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
+
+#define __THRUST_HOST_SYSTEM_ROOT thrust/system/__THRUST_HOST_SYSTEM_NAMESPACE
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab719c9bde9b67d5f7e97ad0846f45e4dad4838b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/memory_resource.h
@@ -0,0 +1,35 @@
+/*
+ *  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 <cstddef>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+
+#define THRUST_MR_DEFAULT_ALIGNMENT THRUST_ALIGNOF(THRUST_NS_QUALIFIER::detail::max_align_t)
+
+#if THRUST_CPP_DIALECT >= 2017
+#  if __has_include(<memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <memory_resource>
+#    define THRUST_MR_STD_MR_NS std::pmr
+#  elif __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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/namespace.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/namespace.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c79046169353f8f373ef124a2b74757bd17da71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/namespace.h
@@ -0,0 +1,120 @@
+/*
+ *  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
+
+/**
+ * \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
+
+/**
+ * \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                                                             \
+  {
+
+/**
+ * \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                                                   \
+  } /* 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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/simple_defines.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/simple_defines.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3ea2eb64e766ea2147ecf1de308a454a739d88e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/config/simple_defines.h
@@ -0,0 +1,30 @@
+/*
+ *  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
+
+#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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.h
new file mode 100644
index 0000000000000000000000000000000000000000..536c1c27c2e9d9c30451b9574300501614676e37
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.h
@@ -0,0 +1,235 @@
+/*
+ *  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/iterator/detail/normal_iterator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct copy_allocator_t {};
+
+// XXX parameter T is redundant with parameter Alloc
+template<typename T, typename Alloc>
+  class contiguous_storage
+{
+  private:
+    typedef thrust::detail::allocator_traits<Alloc> alloc_traits;
+
+  public:
+    typedef Alloc                                      allocator_type;
+    typedef T                                          value_type;
+    typedef typename alloc_traits::pointer             pointer;
+    typedef typename alloc_traits::const_pointer       const_pointer;
+    typedef typename alloc_traits::size_type           size_type;
+    typedef typename alloc_traits::difference_type     difference_type;
+    typedef typename alloc_traits::reference           reference;
+    typedef typename alloc_traits::const_reference     const_reference;
+
+    typedef thrust::detail::normal_iterator<pointer>       iterator;
+    typedef thrust::detail::normal_iterator<const_pointer> const_iterator;
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(const allocator_type &alloc = allocator_type());
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(size_type n, const allocator_type &alloc = allocator_type());
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other);
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other, size_type n);
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    ~contiguous_storage();
+
+    __host__ __device__
+    size_type size() const;
+
+    __host__ __device__
+    size_type max_size() const;
+
+    __host__ __device__
+    pointer data();
+
+    __host__ __device__
+    const_pointer data() const;
+
+    __host__ __device__
+    iterator begin();
+
+    __host__ __device__
+    const_iterator begin() const;
+
+    __host__ __device__
+    iterator end();
+
+    __host__ __device__
+    const_iterator end() const;
+
+    __host__ __device__
+    reference operator[](size_type n);
+
+    __host__ __device__
+    const_reference operator[](size_type n) const;
+
+    __host__ __device__
+    allocator_type get_allocator() const;
+
+    // note that allocate does *not* automatically call deallocate
+    __host__ __device__
+    void allocate(size_type n);
+
+    __host__ __device__
+    void deallocate();
+
+    __host__ __device__
+    void swap(contiguous_storage &x);
+
+    __host__ __device__
+    void default_construct_n(iterator first, size_type n);
+
+    __host__ __device__
+    void uninitialized_fill_n(iterator first, size_type n, const value_type &value);
+
+    template<typename InputIterator>
+    __host__ __device__
+    iterator uninitialized_copy(InputIterator first, InputIterator last, iterator result);
+
+    template<typename System, typename InputIterator>
+    __host__ __device__
+    iterator uninitialized_copy(thrust::execution_policy<System> &from_system,
+                                InputIterator first,
+                                InputIterator last,
+                                iterator result);
+
+    template<typename InputIterator, typename Size>
+    __host__ __device__
+    iterator uninitialized_copy_n(InputIterator first, Size n, iterator result);
+
+    template<typename System, typename InputIterator, typename Size>
+    __host__ __device__
+    iterator uninitialized_copy_n(thrust::execution_policy<System> &from_system,
+                                  InputIterator first,
+                                  Size n,
+                                  iterator result);
+
+    __host__ __device__
+    void destroy(iterator first, iterator last);
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch(const contiguous_storage &other);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch(const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void set_allocator(const allocator_type &alloc);
+
+    __host__ __device__
+    bool is_allocator_not_equal(const allocator_type &alloc) const;
+
+    __host__ __device__
+    bool is_allocator_not_equal(const contiguous_storage &other) const;
+
+    __host__ __device__
+    void propagate_allocator(const contiguous_storage &other);
+
+#if THRUST_CPP_DIALECT >= 2011
+    __host__ __device__
+    void propagate_allocator(contiguous_storage &other);
+
+    // allow move assignment for a sane implementation of allocator propagation
+    // on move assignment
+    __host__ __device__
+    contiguous_storage &operator=(contiguous_storage &&other);
+#endif
+
+  private:
+    // XXX we could inherit from this to take advantage of empty base class optimization
+    allocator_type m_allocator;
+
+    iterator m_begin;
+
+    size_type m_size;
+
+    // disallow assignment
+    contiguous_storage &operator=(const contiguous_storage &x);
+
+    __host__ __device__
+    void swap_allocators(true_type, const allocator_type &);
+
+    __host__ __device__
+    void swap_allocators(false_type, allocator_type &);
+
+    __host__ __device__
+    bool is_allocator_not_equal_dispatch(true_type, const allocator_type &) const;
+
+    __host__ __device__
+    bool is_allocator_not_equal_dispatch(false_type, const allocator_type &) const;
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(true_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(false_type, const contiguous_storage &other);
+
+#if THRUST_CPP_DIALECT >= 2011
+    __host__ __device__
+    void propagate_allocator_dispatch(true_type, contiguous_storage &other);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(false_type, contiguous_storage &other);
+#endif
+}; // end contiguous_storage
+
+} // end detail
+
+template<typename T, typename Alloc>
+__host__ __device__
+void swap(detail::contiguous_storage<T,Alloc> &lhs, detail::contiguous_storage<T,Alloc> &rhs);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/contiguous_storage.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7ae8657f081104ecfd47ab492d53d56e22028ea4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/contiguous_storage.inl
@@ -0,0 +1,550 @@
+/*
+ *  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>
+#include <thrust/detail/contiguous_storage.h>
+#include <thrust/detail/swap.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/allocator/copy_construct_range.h>
+#include <thrust/detail/allocator/default_construct_range.h>
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/fill_construct_range.h>
+
+#include <nv/target>
+
+#include <stdexcept> // for std::runtime_error
+#include <utility> // for use of std::swap in the WAR below
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+class allocator_mismatch_on_swap : public std::runtime_error
+{
+public:
+  allocator_mismatch_on_swap()
+    :std::runtime_error("swap called on containers with allocators that propagate on swap, but compare non-equal")
+  {
+  }
+};
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(const Alloc &alloc)
+      :m_allocator(alloc),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  ;
+} // end contiguous_storage::contiguous_storage()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(size_type n, const Alloc &alloc)
+      :m_allocator(alloc),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  allocate(n);
+} // end contiguous_storage::contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(copy_allocator_t,
+        const contiguous_storage &other)
+      :m_allocator(other.m_allocator),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+} // end contiguous_storage::contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(copy_allocator_t,
+        const contiguous_storage &other, size_type n)
+      :m_allocator(other.m_allocator),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  allocate(n);
+} // end contiguous_storage::contiguous_storage()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::~contiguous_storage()
+{
+  deallocate();
+} // end contiguous_storage::~contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::size_type
+    contiguous_storage<T,Alloc>
+      ::size() const
+{
+  return m_size;
+} // end contiguous_storage::size()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::size_type
+    contiguous_storage<T,Alloc>
+      ::max_size() const
+{
+  return alloc_traits::max_size(m_allocator);
+} // end contiguous_storage::max_size()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::iterator
+    contiguous_storage<T,Alloc>
+      ::begin()
+{
+  return m_begin;
+} // end contiguous_storage::begin()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_iterator
+    contiguous_storage<T,Alloc>
+      ::begin() const
+{
+  return m_begin;
+} // end contiguous_storage::begin()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::iterator
+    contiguous_storage<T,Alloc>
+      ::end()
+{
+  return m_begin + size();
+} // end contiguous_storage::end()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_iterator
+    contiguous_storage<T,Alloc>
+      ::end() const
+{
+  return m_begin + size();
+} // end contiguous_storage::end()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::pointer
+    contiguous_storage<T,Alloc>
+      ::data()
+{
+  return &*m_begin;
+} // end contiguous_storage::data()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_pointer
+    contiguous_storage<T,Alloc>
+      ::data() const
+{
+  return &*m_begin;
+} // end contiguous_storage::data()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::reference
+    contiguous_storage<T,Alloc>
+      ::operator[](size_type n)
+{
+  return m_begin[n];
+} // end contiguous_storage::operator[]()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_reference
+    contiguous_storage<T,Alloc>
+      ::operator[](size_type n) const
+{
+  return m_begin[n];
+} // end contiguous_storage::operator[]()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::allocator_type
+    contiguous_storage<T,Alloc>
+      ::get_allocator() const
+{
+  return m_allocator;
+} // end contiguous_storage::get_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::allocate(size_type n)
+{
+  if(n > 0)
+  {
+    m_begin = iterator(alloc_traits::allocate(m_allocator,n));
+    m_size = n;
+  } // end if
+  else
+  {
+    m_begin = iterator(pointer(static_cast<T*>(0)));
+    m_size = 0;
+  } // end else
+} // end contiguous_storage::allocate()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate()
+{
+  if(size() > 0)
+  {
+    alloc_traits::deallocate(m_allocator,m_begin.base(), size());
+    m_begin = iterator(pointer(static_cast<T*>(0)));
+    m_size = 0;
+  } // end if
+} // end contiguous_storage::deallocate()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap(contiguous_storage &x)
+{
+  thrust::swap(m_begin, x.m_begin);
+  thrust::swap(m_size, x.m_size);
+
+  swap_allocators(
+    integral_constant<
+      bool,
+      allocator_traits<Alloc>::propagate_on_container_swap::value
+    >(),
+    x.m_allocator);
+
+  thrust::swap(m_allocator, x.m_allocator);
+} // end contiguous_storage::swap()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::default_construct_n(iterator first, size_type n)
+{
+  default_construct_range(m_allocator, first.base(), n);
+} // end contiguous_storage::default_construct_n()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::uninitialized_fill_n(iterator first, size_type n, const value_type &x)
+{
+  fill_construct_range(m_allocator, first.base(), n, x);
+} // end contiguous_storage::uninitialized_fill()
+
+template<typename T, typename Alloc>
+  template<typename System, typename InputIterator>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy(thrust::execution_policy<System> &from_system, InputIterator first, InputIterator last, iterator result)
+{
+  return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base()));
+} // end contiguous_storage::uninitialized_copy()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy(InputIterator first, InputIterator last, iterator result)
+{
+  // XXX assumes InputIterator's associated System is default-constructible
+  typename thrust::iterator_system<InputIterator>::type from_system;
+
+  return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base()));
+} // end contiguous_storage::uninitialized_copy()
+
+template<typename T, typename Alloc>
+  template<typename System, typename InputIterator, typename Size>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy_n(thrust::execution_policy<System> &from_system, InputIterator first, Size n, iterator result)
+{
+  return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base()));
+} // end contiguous_storage::uninitialized_copy_n()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator, typename Size>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy_n(InputIterator first, Size n, iterator result)
+{
+  // XXX assumes InputIterator's associated System is default-constructible
+  typename thrust::iterator_system<InputIterator>::type from_system;
+
+  return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base()));
+} // end contiguous_storage::uninitialized_copy_n()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy(iterator first, iterator last)
+{
+  destroy_range(m_allocator, first.base(), last - first);
+} // end contiguous_storage::destroy()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch(const contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  deallocate_on_allocator_mismatch_dispatch(c, other);
+} // end contiguous_storage::deallocate_on_allocator_mismatch
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch(const contiguous_storage &other,
+        iterator first, iterator last)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  destroy_on_allocator_mismatch_dispatch(c, other, first, last);
+} // end contiguous_storage::destroy_on_allocator_mismatch
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::set_allocator(const Alloc &alloc)
+{
+  m_allocator = alloc;
+} // end contiguous_storage::set_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal(const Alloc &alloc) const
+{
+  return is_allocator_not_equal_dispatch(
+    integral_constant<
+      bool,
+      allocator_traits<Alloc>::is_always_equal::value
+    >(),
+    alloc);
+} // end contiguous_storage::is_allocator_not_equal()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal(const contiguous_storage<T,Alloc> &other) const
+{
+  return is_allocator_not_equal(m_allocator, other.m_allocator);
+} // end contiguous_storage::is_allocator_not_equal()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator(const contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  propagate_allocator_dispatch(c, other);
+} // end contiguous_storage::propagate_allocator()
+
+#if THRUST_CPP_DIALECT >= 2011
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator(contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_move_assignment::value
+  > c;
+
+  propagate_allocator_dispatch(c, other);
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc> &contiguous_storage<T,Alloc>
+    ::operator=(contiguous_storage &&other)
+{
+  if (size() > 0)
+  {
+    deallocate();
+  }
+  propagate_allocator(other);
+  m_begin = std::move(other.m_begin);
+  m_size = std::move(other.m_size);
+
+  other.m_begin = pointer(static_cast<T*>(0));
+  other.m_size = 0;
+
+  return *this;
+} // end contiguous_storage::propagate_allocator()
+#endif
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap_allocators(true_type, const Alloc &)
+{
+} // end contiguous_storage::swap_allocators()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap_allocators(false_type, Alloc &other)
+{
+  NV_IF_TARGET(NV_IS_DEVICE, (
+    // allocators must be equal when swapping containers with allocators that propagate on swap
+    assert(!is_allocator_not_equal(other));
+  ), (
+    if (is_allocator_not_equal(other))
+    {
+      throw allocator_mismatch_on_swap();
+    }
+  ));
+
+  thrust::swap(m_allocator, other);
+} // end contiguous_storage::swap_allocators()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal_dispatch(true_type /*is_always_equal*/, const Alloc &) const
+{
+  return false;
+} // end contiguous_storage::is_allocator_not_equal_dispatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal_dispatch(false_type /*!is_always_equal*/, const Alloc& other) const
+{
+  return m_allocator != other;
+} // end contiguous_storage::is_allocator_not_equal_dispatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other)
+{
+  if (m_allocator != other.m_allocator)
+  {
+    deallocate();
+  }
+} // end contiguous_storage::deallocate_on_allocator_mismatch()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &)
+{
+} // end contiguous_storage::deallocate_on_allocator_mismatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other,
+        iterator first, iterator last)
+{
+  if (m_allocator != other.m_allocator)
+  {
+    destroy(first, last);
+  }
+} // end contiguous_storage::destroy_on_allocator_mismatch()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &,
+        iterator, iterator)
+{
+} // end contiguous_storage::destroy_on_allocator_mismatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(true_type, const contiguous_storage &other)
+{
+  m_allocator = other.m_allocator;
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(false_type, const contiguous_storage &)
+{
+} // end contiguous_storage::propagate_allocator()
+
+#if THRUST_CPP_DIALECT >= 2011
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(true_type, contiguous_storage &other)
+{
+  m_allocator = std::move(other.m_allocator);
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(false_type, contiguous_storage &)
+{
+} // end contiguous_storage::propagate_allocator()
+#endif
+
+} // end detail
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void swap(detail::contiguous_storage<T,Alloc> &lhs, detail::contiguous_storage<T,Alloc> &rhs)
+{
+  lhs.swap(rhs);
+} // end swap()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6c5bc805c4cba75175575b07c9744e8bc5e8a2e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.h
@@ -0,0 +1,90 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename System,
+         typename InputIterator,
+         typename OutputIterator>
+__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>
+__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>
+__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>
+__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);
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.inl
new file mode 100644
index 0000000000000000000000000000000000000000..4d62798c705be487e04e9151948601d1be30792f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy.inl
@@ -0,0 +1,129 @@
+/*
+ *  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>
+#include <thrust/detail/copy.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/copy.h>
+#include <thrust/system/detail/adl/copy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename OutputIterator>
+__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
+{
+
+
+__thrust_exec_check_disable__ // because we might call e.g. std::ostream_iterator's constructor
+template<typename System1,
+         typename System2,
+         typename InputIterator,
+         typename OutputIterator>
+__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()
+
+
+__thrust_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>
+__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()
+
+
+} // end detail
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator copy(InputIterator first,
+                      InputIterator last,
+                      OutputIterator result)
+{
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  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)
+{
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.h
new file mode 100644
index 0000000000000000000000000000000000000000..32eb5e08323c856e720a8694a0458747e4049942
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.h
@@ -0,0 +1,71 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__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>
+__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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.inl
new file mode 100644
index 0000000000000000000000000000000000000000..952541c51806cd4b8cb26fadbdebf35363225e71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/copy_if.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>
+#include <thrust/detail/copy_if.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/copy_if.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/adl/copy_if.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__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;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  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;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c48bc5460605604b513b4704fb7b4122744865c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.h
@@ -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>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename EqualityComparable>
+__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>
+__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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.inl
new file mode 100644
index 0000000000000000000000000000000000000000..5d1f628a93c4eea65aacf32ddb256a138a214758
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/count.inl
@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/count.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/count.h>
+#include <thrust/system/detail/adl/count.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+__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)
+{
+  using thrust::system::detail::generic::count;
+  return count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+} // end count()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__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)
+{
+  using thrust::system::detail::generic::count_if;
+  return count_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end count_if()
+
+
+template <typename InputIterator, typename EqualityComparable>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(InputIterator first, InputIterator last, const EqualityComparable& value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::count(select_system(system), first, last, value);
+} // end count()
+
+
+template <typename InputIterator, typename Predicate>
+typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::count_if(select_system(system), first, last, pred);
+} // end count_if()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp11_required.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp11_required.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7fb4fb12cddade3e9a1e83b5310b6cf1a0a5a1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp11_required.h
@@ -0,0 +1,26 @@
+/*
+ *  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/cpp_dialect.h>
+
+#ifndef THRUST_CPP11_REQUIRED_NO_ERROR
+#  if THRUST_CPP_DIALECT < 2011 
+#    error C++11 is required for this Thrust feature; please upgrade your compiler or pass the appropriate -std=c++XX flag to it.
+#  endif
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp14_required.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp14_required.h
new file mode 100644
index 0000000000000000000000000000000000000000..083c8a1ad478f18e8bc5151385362e87ec933962
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cpp14_required.h
@@ -0,0 +1,26 @@
+/*
+ *  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/cpp_dialect.h>
+
+#ifndef THRUST_CPP14_REQUIRED_NO_ERROR
+#  if THRUST_CPP_DIALECT < 2014
+#    error C++14 is required for this Thrust feature; please upgrade your compiler or pass the appropriate -std=c++14 flag to it.
+#  endif
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cstdint.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cstdint.h
new file mode 100644
index 0000000000000000000000000000000000000000..f41e1147576573fcbbd7c729468e881f11e2a6ec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/cstdint.h
@@ -0,0 +1,83 @@
+/*
+ *  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 (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) || \
+    (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG) || \
+    (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_INTEL)
+#include <stdint.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)
+
+#if (_MSC_VER < 1300)
+   typedef signed   char     int8_t;
+   typedef signed   short    int16_t;
+   typedef signed   int      int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed   __int8   int8_t;
+   typedef signed   __int16  int16_t;
+   typedef signed   __int32  int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed   __int64     int64_t;
+typedef unsigned __int64     uint64_t;
+
+#else
+
+typedef ::int8_t   int8_t;
+typedef ::int16_t  int16_t;
+typedef ::int32_t  int32_t;
+typedef ::int64_t  int64_t;
+typedef ::uint8_t  uint8_t;
+typedef ::uint16_t uint16_t;
+typedef ::uint32_t uint32_t;
+typedef ::uint64_t uint64_t;
+
+#endif
+
+
+// an oracle to tell us how to define intptr_t
+template<int word_size = sizeof(void*)> struct divine_intptr_t;
+template<int word_size = sizeof(void*)> struct divine_uintptr_t;
+
+// 32b platforms
+template<>  struct divine_intptr_t<4>  {  typedef thrust::detail::int32_t  type; };
+template<>  struct divine_uintptr_t<4> {  typedef thrust::detail::uint32_t type; };
+
+// 64b platforms
+template<>  struct divine_intptr_t<8>  { typedef thrust::detail::int64_t  type; };
+template<>  struct divine_uintptr_t<8> { typedef thrust::detail::uint64_t type; };
+
+typedef divine_intptr_t<>::type   intptr_t;
+typedef divine_uintptr_t<>::type  uintptr_t;
+
+} // end detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/dependencies_aware_execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/dependencies_aware_execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7567a3fab30e082a251ee234ef0e9cde86c4a30
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/dependencies_aware_execution_policy.h
@@ -0,0 +1,106 @@
+/*
+ *  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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <tuple>
+
+#include <thrust/detail/execute_with_dependencies.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<template<typename> class ExecutionPolicyCRTPBase>
+struct dependencies_aware_execution_policy
+{
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(Dependencies&& ...dependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(dependencies))... };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(std::tuple<Dependencies...>& dependencies) const
+    {
+        return { capture_as_dependency(dependencies) };
+    }
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(std::tuple<Dependencies...>&& dependencies) const
+    {
+        return { capture_as_dependency(std::move(dependencies)) };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(Dependencies&& ...dependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(dependencies))... };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(std::tuple<Dependencies...>& dependencies) const
+    {
+        return { capture_as_dependency(dependencies) };
+    }
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(std::tuple<Dependencies...>&& dependencies) const
+    {
+        return { capture_as_dependency(std::move(dependencies)) };
+    }
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_delete.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_delete.inl
new file mode 100644
index 0000000000000000000000000000000000000000..87f73aad90230ee9e4a3cc659418230fd9e49715
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_delete.inl
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_delete.h>
+#include <thrust/device_free.h>
+#include <thrust/detail/allocator/destroy_range.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// define an empty allocator class to use below
+struct device_delete_allocator {};
+
+}
+
+template<typename T>
+  void device_delete(device_ptr<T> ptr,
+                     const size_t n)
+{
+  // we can use device_allocator to destroy the range
+  thrust::detail::device_delete_allocator a;
+  thrust::detail::destroy_range(a, ptr, n);
+  thrust::device_free(ptr);
+} // end device_delete()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_free.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_free.inl
new file mode 100644
index 0000000000000000000000000000000000000000..806802e16513db0a11fa1b68abaf992eb321fcdc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_free.inl
@@ -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>
+#include <thrust/device_free.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/detail/malloc_and_free.h>
+
+THRUST_NAMESPACE_BEGIN
+
+void device_free(thrust::device_ptr<void> ptr)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef thrust::iterator_system< thrust::device_ptr<void> >::type system;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  thrust::free(s, ptr);
+} // end device_free()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_malloc.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_malloc.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f4222f51da300b49a2498b49c995dc1ae767de37
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_malloc.inl
@@ -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>
+#include <thrust/device_malloc.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/detail/malloc_and_free.h>
+
+THRUST_NAMESPACE_BEGIN
+
+thrust::device_ptr<void> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef thrust::iterator_system< thrust::device_ptr<void> >::type system;
+
+  // 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;
+
+  typedef thrust::iterator_system< thrust::device_ptr<void> >::type system;
+
+  // 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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_new.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_new.inl
new file mode 100644
index 0000000000000000000000000000000000000000..c66e2cbff6cb55c8104c654bb23a5e8b94192f2d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_new.inl
@@ -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>
+#include <thrust/device_new.h>
+#include <thrust/device_malloc.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const size_t n)
+{
+  // XXX TODO dispatch n null device constructors at p here
+  // in the meantime, dispatch 1 null host constructor here
+  // and dispatch n copy constructors
+  return device_new<T>(p, T(), n);
+} // end device_new()
+
+template<typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const T &exemplar,
+                           const size_t n)
+{
+  device_ptr<T> result(reinterpret_cast<T*>(p.get()));
+
+  // run copy constructors at p here
+  thrust::uninitialized_fill(result, result + n, exemplar);
+
+  return result;
+} // end device_new()
+
+template<typename T>
+  device_ptr<T> device_new(const size_t n)
+{
+  // call placement new
+  return device_new<T>(thrust::device_malloc<T>(n));
+} // end device_new()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_ptr.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_ptr.inl
new file mode 100644
index 0000000000000000000000000000000000000000..361c61f3314936a5517f15a409c57a94340c22c5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/device_ptr.inl
@@ -0,0 +1,64 @@
+/*
+ *  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/device_ptr.h>
+#include <thrust/device_reference.h>
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename T>
+  __host__ __device__
+  device_ptr<T> device_pointer_cast(T *ptr)
+{
+  return device_ptr<T>(ptr);
+} // end device_pointer_cast()
+
+template<typename T>
+  __host__ __device__
+  device_ptr<T> device_pointer_cast(const device_ptr<T> &ptr)
+{
+  return ptr;
+} // end device_pointer_cast()
+
+
+namespace detail
+{
+
+template<typename T>
+  struct is_device_ptr< thrust::device_ptr<T> >
+    : public true_type
+{
+}; // end is_device_ptr
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (_MSC_VER <= 1400)
+// XXX WAR MSVC 2005 problem with correctly implementing
+//     pointer_raw_pointer for device_ptr by specializing it here
+template<typename T>
+  struct pointer_raw_pointer< thrust::device_ptr<T> >
+{
+  typedef typename device_ptr<T>::raw_pointer type;
+}; // end pointer_raw_pointer
+#endif
+
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/distance.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/distance.inl
new file mode 100644
index 0000000000000000000000000000000000000000..6702c2b6f738d03810fd3c389852f925f820f77a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/distance.inl
@@ -0,0 +1,35 @@
+/*
+ *  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/advance.h>
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename InputIterator>
+inline __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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/equal.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/equal.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e21ddfa5abb83287dd341986c9b16759a855bc9d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/equal.inl
@@ -0,0 +1,80 @@
+/*
+ *  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>
+#include <thrust/equal.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/equal.h>
+#include <thrust/system/detail/adl/equal.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename System, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+bool equal(const thrust::detail::execution_policy_base<System> &system, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
+  using thrust::system::detail::generic::equal;
+  return equal(thrust::detail::derived_cast(thrust::detail::strip_const(system)), first1, last1, first2);
+} // end equal()
+
+
+__thrust_exec_check_disable__
+template<typename System, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+bool equal(const thrust::detail::execution_policy_base<System> &system, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::equal;
+  return equal(thrust::detail::derived_cast(thrust::detail::strip_const(system)), first1, last1, first2, binary_pred);
+} // end equal()
+
+
+template <typename InputIterator1, typename InputIterator2>
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::equal(select_system(system1,system2), first1, last1, first2);
+}
+
+
+template <typename InputIterator1, typename InputIterator2,
+          typename BinaryPredicate>
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2, BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::equal(select_system(system1,system2), first1, last1, first2, binary_pred);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/event_error.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/event_error.h
new file mode 100644
index 0000000000000000000000000000000000000000..b928e0650c255e5478d85fef343847fade65326b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/event_error.h
@@ -0,0 +1,164 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/// \file thrust/detail/event_error.h
+/// \brief \c thrust::future and thrust::future error handling types and codes.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/system/error_code.h>
+
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+enum class event_errc
+{
+  unknown_event_error
+, no_state
+, no_content
+, last_event_error
+};
+
+/// \return <tt>error_code(static_cast<int>(e), event_category())</tt>
+inline error_code make_error_code(event_errc e);
+
+/// \return <tt>error_condition(static_cast<int>(e), event_category())</tt>.
+inline error_condition make_error_condition(event_errc e);
+
+struct event_error_category : error_category
+{
+  event_error_category() = default;
+
+  virtual char const* name() const
+  {
+    return "event";
+  }
+
+  virtual std::string message(int ev) const
+  {
+    switch (static_cast<event_errc>(ev))
+    {
+      case event_errc::no_state:
+      {
+        return "no_state: an operation that requires an event or future to have "
+               "a stream or content has been performed on a event or future "
+               "without either, e.g. a moved-from or default constructed event "
+               "or future (an event or future may have been consumed more than "
+               "once)";
+      }
+      case event_errc::no_content:
+      {
+        return "no_content: an operation that requires a future to have content "
+               "has been performed on future without any, e.g. a moved-from, "
+               "default constructed, or `thrust::new_stream` constructed future "
+               "(a future may have been consumed more than once)";
+      }
+      default:
+      {
+        return "unknown_event_error: an unknown error with a future "
+               "object has occurred";
+      }
+    };
+  }
+
+  virtual error_condition default_error_condition(int ev) const
+  {
+    if (
+         event_errc::last_event_error
+         >
+         static_cast<event_errc>(ev)
+       )
+      return make_error_condition(static_cast<event_errc>(ev));
+
+    return system_category().default_error_condition(ev);
+  }
+};
+
+/// Obtains a reference to the static error category object for the errors
+/// related to futures and promises. The object is required to override the
+/// virtual function error_category::name() to return a pointer to the string
+/// "event". It is used to identify error codes provided in the
+/// exceptions of type event_error.
+inline error_category const& event_category()
+{
+  static const event_error_category result;
+  return result;
+}
+
+namespace system
+{
+/// Specialization of \p is_error_code_enum for \p event_errc.
+template<> struct is_error_code_enum<event_errc> : true_type {};
+} // end system
+
+/// \return <tt>error_code(static_cast<int>(e), event_category())</tt>
+inline error_code make_error_code(event_errc e)
+{
+  return error_code(static_cast<int>(e), event_category());
+}
+
+/// \return <tt>error_condition(static_cast<int>(e), event_category())</tt>.
+inline error_condition make_error_condition(event_errc e)
+{
+  return error_condition(static_cast<int>(e), event_category());
+}
+
+struct event_error : std::logic_error
+{
+  __host__
+  explicit event_error(error_code ec)
+    : std::logic_error(ec.message()), ec_(ec)
+  {}
+
+  __host__
+  explicit event_error(event_errc e)
+    : event_error(make_error_code(e))
+  {}
+
+  __host__
+  error_code const& code() const noexcept
+  {
+    return ec_;
+  }
+
+  __host__
+  virtual ~event_error() noexcept {}
+
+private:
+  error_code ec_;
+};
+
+inline bool operator==(event_error const& lhs, event_error const& rhs) noexcept
+{
+  return lhs.code() == rhs.code();
+}
+
+inline bool operator<(event_error const& lhs, event_error const& rhs) noexcept
+{
+  return lhs.code() < rhs.code();
+}
+
+THRUST_NAMESPACE_END
+
+#endif // C++14
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..430fe739c3f4ce938a1dcb979789dfdac75f0d61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator.h
@@ -0,0 +1,149 @@
+/*
+ *  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>
+
+#include <thrust/detail/execute_with_allocator_fwd.h>
+#include <thrust/pair.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/integer_math.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <
+    typename T
+  , typename Allocator
+  , template <typename> class BaseSystem
+>
+__host__
+thrust::pair<T*, std::ptrdiff_t>
+get_temporary_buffer(
+    thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system
+  , std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::void_pointer                        void_pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          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
+>
+__host__
+void
+return_temporary_buffer(
+    thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system
+  , Pointer p
+  , std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::pointer                             pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+  typedef typename thrust::detail::pointer_traits<Pointer>::element_type T;
+
+  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);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template <
+    typename T,
+    template <typename> class BaseSystem,
+    typename Allocator,
+    typename ...Dependencies
+>
+__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
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::void_pointer                        void_pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          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
+>
+__host__
+void
+return_temporary_buffer(
+    thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+    Pointer p,
+    std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::pointer                             pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+  typedef typename thrust::detail::pointer_traits<Pointer>::element_type T;
+
+  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);
+}
+
+#endif
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator_fwd.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator_fwd.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d5899a7db76e3608a9ffd3ea5ae0f46d7d44ee7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_allocator_fwd.h
@@ -0,0 +1,106 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <thrust/detail/execute_with_dependencies.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename Allocator, template <typename> class BaseSystem>
+struct execute_with_allocator
+  : BaseSystem<execute_with_allocator<Allocator, BaseSystem> >
+{
+private:
+  typedef BaseSystem<execute_with_allocator<Allocator, BaseSystem> > super_t;
+
+  Allocator alloc;
+
+public:
+  __host__ __device__
+  execute_with_allocator(super_t const& super, Allocator alloc_)
+    : super_t(super), alloc(alloc_)
+  {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  execute_with_allocator(Allocator alloc_)
+    : alloc(alloc_)
+  {}
+
+  typename remove_reference<Allocator>::type& get_allocator() { return alloc; }
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  after(Dependencies&& ...dependencies) const
+  {
+    return { alloc, capture_as_dependency(THRUST_FWD(dependencies))... };
+  }
+
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  after(std::tuple<Dependencies...>& dependencies) const
+  {
+      return { alloc, capture_as_dependency(dependencies) };
+  }
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  after(std::tuple<Dependencies...>&& dependencies) const
+  {
+      return { alloc, capture_as_dependency(std::move(dependencies)) };
+  }
+
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  rebind_after(Dependencies&& ...dependencies) const
+  {
+    return { alloc, capture_as_dependency(THRUST_FWD(dependencies))... };
+  }
+
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>& dependencies) const
+  {
+      return { alloc, capture_as_dependency(dependencies) };
+  }
+  template<typename ...Dependencies>
+  __host__
+  execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>
+  rebind_after(std::tuple<Dependencies...>&& dependencies) const
+  {
+      return { alloc, capture_as_dependency(std::move(dependencies)) };
+  }
+#endif
+};
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_dependencies.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_dependencies.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec54010b0520f3b83bb248420a1456268616470f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execute_with_dependencies.h
@@ -0,0 +1,267 @@
+/*
+ *  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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <tuple>
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct capture_as_dependency_fn
+{
+  template<typename Dependency>
+  auto operator()(Dependency&& dependency) const
+  THRUST_DECLTYPE_RETURNS(capture_as_dependency(THRUST_FWD(dependency)))
+};
+
+// Default implementation: universal forwarding.
+template<typename Dependency>
+auto capture_as_dependency(Dependency&& dependency)
+THRUST_DECLTYPE_RETURNS(THRUST_FWD(dependency))
+
+template<typename... Dependencies>
+auto capture_as_dependency(std::tuple<Dependencies...>& dependencies)
+THRUST_DECLTYPE_RETURNS(
+  tuple_for_each(THRUST_FWD(dependencies), capture_as_dependency_fn{})
+)
+
+template<template<typename> class BaseSystem, typename... Dependencies>
+struct execute_with_dependencies
+    : BaseSystem<execute_with_dependencies<BaseSystem, Dependencies...>>
+{
+private:
+    using super_t = BaseSystem<execute_with_dependencies<BaseSystem, Dependencies...>>;
+
+    std::tuple<remove_cvref_t<Dependencies>...> dependencies;
+
+public:
+    __host__
+    execute_with_dependencies(super_t const &super, Dependencies && ...dependencies)
+        : super_t(super), dependencies(std::forward<Dependencies>(dependencies)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(super_t const &super, UDependencies && ...deps)
+        : super_t(super), dependencies(THRUST_FWD(deps)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(UDependencies && ...deps)
+        : dependencies(THRUST_FWD(deps)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(super_t const &super, std::tuple<UDependencies...>&& deps)
+        : super_t(super), dependencies(std::move(deps))
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(std::tuple<UDependencies...>&& deps)
+        : dependencies(std::move(deps))
+    {
+    }
+
+    std::tuple<remove_cvref_t<Dependencies>...>
+    __host__
+    extract_dependencies() 
+    {
+        return std::move(dependencies);
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(UDependencies&& ...udependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(udependencies))... };
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>& udependencies) const
+    {
+        return { capture_as_dependency(udependencies) };
+    }
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>&& udependencies) const
+    {
+        return { capture_as_dependency(std::move(udependencies)) };
+    }
+};
+
+template<
+    typename Allocator,
+    template<typename> class BaseSystem,
+    typename... Dependencies
+>
+struct execute_with_allocator_and_dependencies
+    : BaseSystem<
+        execute_with_allocator_and_dependencies<
+            Allocator,
+            BaseSystem,
+            Dependencies...
+        >
+    >
+{
+private:
+    using super_t = BaseSystem<
+        execute_with_allocator_and_dependencies<
+            Allocator,
+            BaseSystem,
+            Dependencies...
+        >
+    >;
+
+    std::tuple<remove_cvref_t<Dependencies>...> dependencies;
+    Allocator alloc;
+
+public:
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(super_t const &super, Allocator a, UDependencies && ...deps)
+        : super_t(super), dependencies(THRUST_FWD(deps)...), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(Allocator a, UDependencies && ...deps)
+        : dependencies(THRUST_FWD(deps)...), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(super_t const &super, Allocator a, std::tuple<UDependencies...>&& deps)
+        : super_t(super), dependencies(std::move(deps)), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(Allocator a, std::tuple<UDependencies...>&& deps)
+        : dependencies(std::move(deps)), alloc(a)
+    {
+    }
+
+    std::tuple<remove_cvref_t<Dependencies>...>
+    __host__
+    extract_dependencies() 
+    {
+        return std::move(dependencies);
+    }
+
+    __host__
+    typename std::add_lvalue_reference<Allocator>::type
+    get_allocator()
+    {
+        return alloc;
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(UDependencies&& ...udependencies) const
+    {
+        return { alloc, capture_as_dependency(THRUST_FWD(udependencies))... };
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>& udependencies) const
+    {
+        return { alloc, capture_as_dependency(udependencies) };
+    }
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>&& udependencies) const
+    {
+        return { alloc, capture_as_dependency(std::move(udependencies)) };
+    }
+};
+
+template<template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_dependencies<BaseSystem, Dependencies...>&& system)
+{
+    return std::move(system).extract_dependencies();
+}
+template<template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_dependencies<BaseSystem, Dependencies...>& system)
+{
+    return std::move(system).extract_dependencies();
+}
+
+template<typename Allocator, template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>&& system)
+{
+    return std::move(system).extract_dependencies();
+}
+template<typename Allocator, template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system)
+{
+    return std::move(system).extract_dependencies();
+}
+
+template<typename System>
+__host__
+std::tuple<>
+extract_dependencies(System &&)
+{
+    return std::tuple<>{};
+}
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..dcc11a770331b9e52c6614f6eb713835a7a8abdc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/execution_policy.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>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct execution_policy_marker {};
+
+// execution_policy_base serves as a guard against
+// inifinite recursion in thrust entry points:
+//
+// template<typename DerivedPolicy>
+// void foo(const thrust::detail::execution_policy_base<DerivedPolicy> &s)
+// {
+//   using thrust::system::detail::generic::foo;
+//
+//   foo(thrust::detail::derived_cast(thrust::detail::strip_const(s));
+// }
+//
+// foo is not recursive when
+// 1. DerivedPolicy is derived from thrust::execution_policy below
+// 2. generic::foo takes thrust::execution_policy as a parameter
+template<typename DerivedPolicy>
+struct execution_policy_base : execution_policy_marker {};
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+execution_policy_base<DerivedPolicy> &strip_const(const execution_policy_base<DerivedPolicy> &x)
+{
+  return const_cast<execution_policy_base<DerivedPolicy>&>(x);
+}
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+DerivedPolicy &derived_cast(execution_policy_base<DerivedPolicy> &x)
+{
+  return static_cast<DerivedPolicy&>(x);
+}
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+const DerivedPolicy &derived_cast(const execution_policy_base<DerivedPolicy> &x)
+{
+  return static_cast<const DerivedPolicy&>(x);
+}
+
+} // end detail
+
+template<typename DerivedPolicy>
+  struct execution_policy
+    : thrust::detail::execution_policy_base<DerivedPolicy>
+{};
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/extrema.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/extrema.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2c1750e7d481d2359c38fd21ea8b7764361bcb8c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/extrema.inl
@@ -0,0 +1,169 @@
+/*
+ *  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>
+#include <thrust/extrema.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/extrema.h>
+#include <thrust/system/detail/adl/extrema.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last, comp);
+} // end minmax_element()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/fill.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/fill.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e68672bbebef2d6ea2df89f661e2a88825b82bcc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/fill.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>
+
+#include <thrust/fill.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/fill.h>
+#include <thrust/system/detail/adl/fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T &value)
+{
+  using thrust::system::detail::generic::fill;
+  return fill(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+} // end fill()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename OutputIterator, typename Size, typename T>
+__host__ __device__
+  OutputIterator fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        OutputIterator first,
+                        Size n,
+                        const T &value)
+{
+  using thrust::system::detail::generic::fill_n;
+  return fill_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, value);
+} // end fill_n()
+
+
+template<typename ForwardIterator, typename T>
+__host__ __device__
+  void fill(ForwardIterator first,
+            ForwardIterator last,
+            const T &value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  thrust::fill(select_system(system), first, last, value);
+} // end fill()
+
+
+template<typename OutputIterator, typename Size, typename T>
+__host__ __device__
+  OutputIterator fill_n(OutputIterator first,
+                        Size n,
+                        const T &value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<OutputIterator>::type System;
+
+  System system;
+
+  return thrust::fill_n(select_system(system), first, n, value);
+} // end fill()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/find.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/find.inl
new file mode 100644
index 0000000000000000000000000000000000000000..5b494f61a60d0dfe7a58a954722058a54e8d830e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/find.inl
@@ -0,0 +1,108 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/find.h>
+#include <thrust/system/detail/adl/find.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+InputIterator find(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   const T& value)
+{
+  using thrust::system::detail::generic::find;
+  return find(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+} // end find()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  using thrust::system::detail::generic::find_if;
+  return find_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end find_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if_not(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::find_if_not;
+  return find_if_not(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end find_if_not()
+
+
+template <typename InputIterator, typename T>
+InputIterator find(InputIterator first,
+                   InputIterator last,
+                   const T& value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::find(select_system(system), first, last, value);
+}
+
+template <typename InputIterator, typename Predicate>
+InputIterator find_if(InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::find_if(select_system(system), first, last, pred);
+}
+
+template <typename InputIterator, typename Predicate>
+InputIterator find_if_not(InputIterator first,
+                          InputIterator last,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::find_if_not(select_system(system), first, last, pred);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/for_each.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/for_each.inl
new file mode 100644
index 0000000000000000000000000000000000000000..4ba39c71a406d41b466f496c3b812bcf02bf9f91
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/for_each.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>
+#include <thrust/for_each.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/for_each.h>
+#include <thrust/system/detail/adl/for_each.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename UnaryFunction>
+__host__ __device__
+  InputIterator for_each(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         UnaryFunction f)
+{
+  using thrust::system::detail::generic::for_each;
+
+  return for_each(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, f);
+}
+
+
+template<typename InputIterator,
+         typename UnaryFunction>
+InputIterator for_each(InputIterator first,
+                       InputIterator last,
+                       UnaryFunction f)
+{
+  using thrust::system::detail::generic::select_system;
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+  return thrust::for_each(select_system(system), first, last, f);
+} // end for_each()
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename UnaryFunction>
+__host__ __device__
+  InputIterator for_each_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           Size n,
+                           UnaryFunction f)
+{
+  using thrust::system::detail::generic::for_each_n;
+
+  return for_each_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, f);
+} // end for_each_n()
+
+
+template<typename InputIterator,
+         typename Size,
+         typename UnaryFunction>
+InputIterator for_each_n(InputIterator first,
+                         Size n,
+                         UnaryFunction f)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+  return thrust::for_each_n(select_system(system), first, n, f);
+} // end for_each_n()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba20507a54771a3dcd9d612ca751fc9f04c09e29
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/function.h
@@ -0,0 +1,161 @@
+/*
+ *  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>
+#include <thrust/detail/raw_reference_cast.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename Function, typename Result>
+struct wrapped_function
+{
+  // mutable because Function::operator() might be const
+  mutable Function m_f;
+
+  inline __host__ __device__
+  wrapped_function()
+      : m_f()
+  {}
+
+  inline __host__ __device__
+  wrapped_function(const Function& f)
+      : m_f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument& x) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument& x) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument1& x, Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument1& x, Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument1& x, const Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument1& x, const Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+}; // end wrapped_function
+
+// Specialize for void return types:
+template <typename Function>
+struct wrapped_function<Function, void>
+{
+  // mutable because Function::operator() might be const
+  mutable Function m_f;
+  inline __host__ __device__
+  wrapped_function()
+    : m_f()
+  {}
+
+  inline __host__ __device__
+  wrapped_function(const Function& f)
+    : m_f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument& x) const
+  {
+    m_f(thrust::raw_reference_cast(x));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument& x) const
+  {
+    m_f(thrust::raw_reference_cast(x));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument1& x, Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument1& x, Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument1& x, const Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument1& x, const Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+}; // end wrapped_function
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional.inl
new file mode 100644
index 0000000000000000000000000000000000000000..bdf8e0415297e4136898b66f167f4ea045622559
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional.inl
@@ -0,0 +1,126 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename Operation>
+  struct unary_traits_imp;
+
+template<typename Operation>
+  struct unary_traits_imp<Operation*>
+{
+  typedef Operation                         function_type;
+  typedef const function_type &             param_type;
+  typedef typename Operation::result_type   result_type;
+  typedef typename Operation::argument_type argument_type;
+}; // end unary_traits_imp
+
+template<typename Result, typename Argument>
+  struct unary_traits_imp<Result(*)(Argument)>
+{
+  typedef Result   (*function_type)(Argument);
+  typedef Result   (*param_type)(Argument);
+  typedef Result   result_type;
+  typedef Argument argument_type;
+}; // end unary_traits_imp
+
+template<typename Operation>
+  struct binary_traits_imp;
+
+template<typename Operation>
+  struct binary_traits_imp<Operation*>
+{
+  typedef Operation                                function_type;
+  typedef const function_type &                    param_type;
+  typedef typename Operation::result_type          result_type;
+  typedef typename Operation::first_argument_type  first_argument_type;
+  typedef typename Operation::second_argument_type second_argument_type;
+}; // end binary_traits_imp
+
+template<typename Result, typename Argument1, typename Argument2>
+  struct binary_traits_imp<Result(*)(Argument1, Argument2)>
+{
+  typedef Result (*function_type)(Argument1, Argument2);
+  typedef Result (*param_type)(Argument1, Argument2);
+  typedef Result result_type;
+  typedef Argument1 first_argument_type;
+  typedef Argument2 second_argument_type;
+}; // end binary_traits_imp
+
+} // end detail
+
+template<typename Operation>
+  struct unary_traits
+{
+  typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
+  typedef typename detail::unary_traits_imp<Operation*>::param_type    param_type;
+  typedef typename detail::unary_traits_imp<Operation*>::result_type   result_type;
+  typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
+}; // end unary_traits
+
+template<typename Result, typename Argument>
+  struct unary_traits<Result(*)(Argument)>
+{
+  typedef Result   (*function_type)(Argument);
+  typedef Result   (*param_type)(Argument);
+  typedef Result   result_type;
+  typedef Argument argument_type;
+}; // end unary_traits
+
+template<typename Operation>
+  struct binary_traits
+{
+  typedef typename detail::binary_traits_imp<Operation*>::function_type        function_type;
+  typedef typename detail::binary_traits_imp<Operation*>::param_type           param_type;
+  typedef typename detail::binary_traits_imp<Operation*>::result_type          result_type;
+  typedef typename detail::binary_traits_imp<Operation*>::first_argument_type  first_argument_type;
+  typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
+}; // end binary_traits
+
+template<typename Result, typename Argument1, typename Argument2>
+  struct binary_traits<Result(*)(Argument1, Argument2)>
+{
+  typedef Result (*function_type)(Argument1, Argument2);
+  typedef Result (*param_type)(Argument1, Argument2);
+  typedef Result result_type;
+  typedef Argument1 first_argument_type;
+  typedef Argument2 second_argument_type;
+}; // end binary_traits
+
+template<typename Predicate>
+  __host__ __device__
+  unary_negate<Predicate> not1(const Predicate &pred)
+{
+  return unary_negate<Predicate>(pred);
+} // end not1()
+
+template<typename BinaryPredicate>
+  __host__ __device__
+  binary_negate<BinaryPredicate> not2(const BinaryPredicate &pred)
+{
+  return binary_negate<BinaryPredicate>(pred);
+} // end not2()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.h
new file mode 100644
index 0000000000000000000000000000000000000000..cee0770a46b64df927b7733e6286ddbbe64bcd06
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.h
@@ -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.
+ */
+
+// 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>
+#include <thrust/tuple.h>
+#include <thrust/detail/functional/value.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/assignment_operator.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+// eval_ref<T> is
+// - T when T is a subclass of thrust::reference
+// - T& otherwise
+// This is used to let thrust::references pass through actor evaluations.
+template <typename T>
+using eval_ref = typename std::conditional<
+  thrust::detail::is_wrapped_reference<T>::value, T, T&>::type;
+
+template<typename Action, typename Env>
+  struct apply_actor
+{
+  typedef typename Action::template result<Env>::type type;
+};
+
+template<typename Eval>
+  struct actor
+    : Eval
+{
+  typedef Eval eval_type;
+
+  __host__ __device__
+  constexpr actor();
+
+  __host__ __device__
+  actor(const Eval &base);
+
+  __host__ __device__
+  typename apply_actor<eval_type, thrust::null_type >::type
+  operator()(void) const;
+
+  template <typename... Ts>
+  __host__ __device__
+  typename apply_actor<eval_type, thrust::tuple<eval_ref<Ts>...>>::type
+  operator()(Ts&&... ts) const;
+
+  template<typename T>
+  __host__ __device__
+  typename assign_result<Eval,T>::type
+  operator=(const T &_1) const;
+}; // end actor
+
+// in general, as_actor should turn things into values
+template<typename T>
+  struct as_actor
+{
+  typedef value<T> type;
+
+  static inline __host__ __device__ type convert(const T &x)
+  {
+    return val(x);
+  } // end convert()
+}; // end as_actor
+
+// specialization for things which are already actors
+template<typename Eval>
+  struct as_actor<actor<Eval> >
+{
+  typedef actor<Eval> type;
+
+  static inline __host__ __device__ const type &convert(const actor<Eval> &x)
+  {
+    return x;
+  } // end convert()
+}; // end as_actor
+
+template<typename T>
+  typename as_actor<T>::type
+  __host__ __device__
+    make_actor(const T &x)
+{
+  return as_actor<T>::convert(x);
+} // end make_actor()
+
+} // end functional
+
+// provide specializations for result_of for nullary, unary, and binary invocations of actor
+template<typename Eval>
+  struct result_of_adaptable_function<
+    thrust::detail::functional::actor<Eval>()
+  >
+{
+  typedef typename thrust::detail::functional::apply_actor<
+    thrust::detail::functional::actor<Eval>,
+    thrust::null_type
+  >::type type;
+}; // end result_of
+
+template<typename Eval, typename Arg1>
+  struct result_of_adaptable_function<
+    thrust::detail::functional::actor<Eval>(Arg1)
+  >
+{
+  typedef typename thrust::detail::functional::apply_actor<
+    thrust::detail::functional::actor<Eval>,
+    thrust::tuple<Arg1>
+  >::type type;
+}; // end result_of
+
+template<typename Eval, typename Arg1, typename Arg2>
+  struct result_of_adaptable_function<
+    thrust::detail::functional::actor<Eval>(Arg1,Arg2)
+  >
+{
+  typedef typename thrust::detail::functional::apply_actor<
+    thrust::detail::functional::actor<Eval>,
+    thrust::tuple<Arg1,Arg2>
+  >::type type;
+}; // end result_of
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/functional/actor.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e0bdebbbf3eaa977685f02798b05f8f5c71cf0ec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/actor.inl
@@ -0,0 +1,114 @@
+/*
+ *  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.
+ */
+
+// 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>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/assignment_operator.h>
+#include <thrust/functional.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+namespace functional
+{
+
+template<typename Eval>
+  __host__ __device__
+  constexpr actor<Eval>
+    ::actor()
+      : eval_type()
+{}
+
+template<typename Eval>
+  __host__ __device__
+  actor<Eval>
+    ::actor(const Eval &base)
+      : eval_type(base)
+{}
+
+template<typename Eval>
+  __host__ __device__
+  typename apply_actor<
+    typename actor<Eval>::eval_type,
+    typename thrust::null_type
+  >::type
+    actor<Eval>
+      ::operator()(void) const
+{
+  return eval_type::eval(thrust::null_type());
+} // end basic_environment::operator()
+
+// actor::operator() needs to construct a tuple of references to its
+// arguments. To make this work with thrust::reference<T>, we need to
+// detect thrust proxy references and store them as T rather than T&.
+// This check ensures that the forwarding references passed into
+// actor::operator() are either:
+// - T&& if and only if T is a thrust::reference<U>, or
+// - T& for any other types.
+// This struct provides a nicer diagnostic for when these conditions aren't
+// met.
+template <typename T>
+using actor_check_ref_type =
+  thrust::detail::integral_constant<bool,
+    ( std::is_lvalue_reference<T>::value ||
+      thrust::detail::is_wrapped_reference<T>::value )>;
+
+template <typename... Ts>
+using actor_check_ref_types =
+  thrust::conjunction<actor_check_ref_type<Ts>...>;
+
+template<typename Eval>
+template<typename... Ts>
+__host__ __device__
+typename apply_actor<typename actor<Eval>::eval_type,
+                     thrust::tuple<eval_ref<Ts>...>>::type
+actor<Eval>::operator()(Ts&&... ts) const
+{
+  static_assert(actor_check_ref_types<Ts...>::value,
+                "Actor evaluations only support rvalue references to "
+                "thrust::reference subclasses.");
+  using tuple_type = thrust::tuple<eval_ref<Ts>...>;
+  return eval_type::eval(tuple_type(THRUST_FWD(ts)...));
+} // end actor<Eval>::operator()
+
+template<typename Eval>
+  template<typename T>
+    __host__ __device__
+    typename assign_result<Eval,T>::type
+      actor<Eval>
+        ::operator=(const T& _1) const
+{
+  return do_assign(*this,_1);
+} // end actor::operator=()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/argument.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/argument.h
new file mode 100644
index 0000000000000000000000000000000000000000..aac29f53713e94edc0c1c7ab4578e347871c84e6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/argument.h
@@ -0,0 +1,74 @@
+/*
+ *  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.
+ */
+
+// 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>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<unsigned int i, typename Env>
+  struct argument_helper
+{
+  typedef typename thrust::tuple_element<i,Env>::type type;
+};
+
+template<unsigned int i>
+  struct argument_helper<i,thrust::null_type>
+{
+  typedef thrust::null_type type;
+};
+
+
+template<unsigned int i>
+  class argument
+{
+  public:
+    template<typename Env>
+      struct result
+        : argument_helper<i,Env>
+    {
+    };
+
+    __host__ __device__
+    constexpr argument(){}
+
+    template<typename Env>
+    __host__ __device__
+    typename result<Env>::type eval(const Env &e) const
+    {
+      return thrust::get<i>(e);
+    } // end eval()
+}; // end argument
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/composite.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/composite.h
new file mode 100644
index 0000000000000000000000000000000000000000..41ee74739254db8e51080854ed5d07d13c8a515a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/composite.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.
+ */
+
+// 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>
+
+#include <thrust/detail/functional/actor.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+// XXX we should just take a single EvalTuple
+template<typename Eval0,
+         typename Eval1  = thrust::null_type,
+         typename Eval2  = thrust::null_type,
+         typename Eval3  = thrust::null_type,
+         typename Eval4  = thrust::null_type,
+         typename Eval5  = thrust::null_type,
+         typename Eval6  = thrust::null_type,
+         typename Eval7  = thrust::null_type,
+         typename Eval8  = thrust::null_type,
+         typename Eval9  = thrust::null_type,
+         typename Eval10 = thrust::null_type>
+  class composite;
+
+template<typename Eval0, typename Eval1>
+  class composite<
+    Eval0,
+    Eval1,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type
+  >
+{
+  public:
+    template<typename Env>
+      struct result
+    {
+      typedef typename Eval0::template result<
+        thrust::tuple<
+          typename Eval1::template result<Env>::type
+        >
+      >::type type;
+    };
+
+    __host__ __device__
+    composite(const Eval0 &e0, const Eval1 &e1)
+      : m_eval0(e0),
+        m_eval1(e1)
+    {}
+
+    template<typename Env>
+    __host__ __device__
+    typename result<Env>::type
+    eval(const Env &x) const
+    {
+      typename Eval1::template result<Env>::type result1 = m_eval1.eval(x);
+      return m_eval0.eval(thrust::tie(result1));
+    }
+
+  private:
+    Eval0 m_eval0;
+    Eval1 m_eval1;
+}; // end composite<Eval0,Eval1>
+
+template<typename Eval0, typename Eval1, typename Eval2>
+  class composite<
+    Eval0,
+    Eval1,
+    Eval2,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type,
+    thrust::null_type
+  >
+{
+  public:
+    template<typename Env>
+      struct result
+    {
+      typedef typename Eval0::template result<
+        thrust::tuple<
+          typename Eval1::template result<Env>::type,
+          typename Eval2::template result<Env>::type
+        >
+      >::type type;
+    };
+
+    __host__ __device__
+    composite(const Eval0 &e0, const Eval1 &e1, const Eval2 &e2)
+      : m_eval0(e0),
+        m_eval1(e1),
+        m_eval2(e2)
+    {}
+
+    template<typename Env>
+    __host__ __device__
+    typename result<Env>::type
+    eval(const Env &x) const
+    {
+      typename Eval1::template result<Env>::type result1 = m_eval1.eval(x);
+      typename Eval2::template result<Env>::type result2 = m_eval2.eval(x);
+      return m_eval0.eval(thrust::tie(result1,result2));
+    }
+
+  private:
+    Eval0 m_eval0;
+    Eval1 m_eval1;
+    Eval2 m_eval2;
+}; // end composite<Eval0,Eval1,Eval2>
+
+template<typename Eval0, typename Eval1>
+__host__ __device__
+  actor<composite<Eval0,Eval1> > compose(const Eval0 &e0, const Eval1 &e1)
+{
+  return actor<composite<Eval0,Eval1> >(composite<Eval0,Eval1>(e0,e1));
+}
+
+template<typename Eval0, typename Eval1, typename Eval2>
+__host__ __device__
+  actor<composite<Eval0,Eval1,Eval2> > compose(const Eval0 &e0, const Eval1 &e1, const Eval2 &e2)
+{
+  return actor<composite<Eval0,Eval1,Eval2> >(composite<Eval0,Eval1,Eval2>(e0,e1,e2));
+}
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..f86ea20521811911e53812320e134a1e5c68079c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators.h
@@ -0,0 +1,25 @@
+/*
+ *  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>
+#include <thrust/detail/functional/operators/arithmetic_operators.h>
+#include <thrust/detail/functional/operators/relational_operators.h>
+#include <thrust/detail/functional/operators/logical_operators.h>
+#include <thrust/detail/functional/operators/bitwise_operators.h>
+#include <thrust/detail/functional/operators/compound_assignment_operators.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..443d307cbd60c194d200a2027804c16ec327e0c0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h
@@ -0,0 +1,436 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<thrust::negate<>>,
+    actor<Eval>
+  >
+>
+__host__ __device__
+operator-(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<thrust::negate<>>(), _1);
+} // end operator-()
+
+// there's no standard unary_plus functional, so roll an ad hoc one here
+struct unary_plus
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(+THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(+THRUST_FWD(t1)))
+  {
+    return +THRUST_FWD(t1);
+  }
+};
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<unary_plus>,
+    actor<Eval>
+  >
+>
+operator+(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<unary_plus>(), _1);
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator+(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator+(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator+(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator-(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator-(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator-(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator*(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator*(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator*(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator/(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator/(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator/(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator%(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator%(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<void>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator%(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+// there's no standard prefix_increment functional, so roll an ad hoc one here
+struct prefix_increment
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(++THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(++THRUST_FWD(t1)))
+  {
+    return ++THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<prefix_increment>,
+    actor<Eval>
+  >
+>
+operator++(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<prefix_increment>(), _1);
+} // end operator++()
+
+
+// there's no standard postfix_increment functional, so roll an ad hoc one here
+struct postfix_increment
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(THRUST_FWD(t1)++))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)++))
+  {
+    return THRUST_FWD(t1)++;
+  }
+}; // end postfix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<postfix_increment>,
+    actor<Eval>
+  >
+>
+operator++(const actor<Eval> &_1, int)
+{
+  return compose(transparent_unary_operator<postfix_increment>(), _1);
+} // end operator++()
+
+
+// there's no standard prefix_decrement functional, so roll an ad hoc one here
+struct prefix_decrement
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(--THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(--THRUST_FWD(t1)))
+  {
+    return --THRUST_FWD(t1);
+  }
+}; // end prefix_decrement
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<prefix_decrement>,
+    actor<Eval>
+  >
+>
+operator--(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<prefix_decrement>(), _1);
+} // end operator--()
+
+
+// there's no standard postfix_decrement functional, so roll an ad hoc one here
+struct postfix_decrement
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(THRUST_FWD(t1)--))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)--))
+  {
+    return THRUST_FWD(t1)--;
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<postfix_decrement>,
+    actor<Eval>
+  >
+>
+operator--(const actor<Eval> &_1, int)
+{
+  return compose(transparent_unary_operator<postfix_decrement>(), _1);
+} // end operator--()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/assignment_operator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/assignment_operator.h
new file mode 100644
index 0000000000000000000000000000000000000000..870354b6f0b59197cc7d80bb66a490f7ac81b5cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/assignment_operator.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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// XXX WAR circular inclusion with this forward declaration
+template<typename,typename,typename> struct binary_function;
+
+namespace detail
+{
+namespace functional
+{
+
+// XXX WAR circular inclusion with this forward declaration
+template<typename> struct as_actor;
+
+// there's no standard assign functional, so roll an ad hoc one here
+struct assign
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) = THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) = THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) = THRUST_FWD(t2);
+  }
+};
+
+template<typename Eval, typename T>
+  struct assign_result
+{
+  typedef actor<
+    composite<
+      transparent_binary_operator<assign>,
+      actor<Eval>,
+      typename as_actor<T>::type
+    >
+  > type;
+}; // end assign_result
+
+template<typename Eval, typename T>
+  __host__ __device__
+    typename assign_result<Eval,T>::type
+      do_assign(const actor<Eval> &_1, const T &_2)
+{
+  return compose(transparent_binary_operator<assign>(),
+                 _1,
+                 as_actor<T>::convert(_2));
+} // end do_assign()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/bitwise_operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/bitwise_operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..065cd15403c764d00451c95bd3b72807d65451ae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/bitwise_operators.h
@@ -0,0 +1,338 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator&(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator|(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator|(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator|(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator^(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator^(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator^(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+
+// there's no standard bit_not functional, so roll an ad hoc one here
+struct bit_not
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(~THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(~THRUST_FWD(t1)))
+  {
+    return ~THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<bit_not>,
+    actor<Eval>
+  >
+>
+__host__ __device__
+operator~(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<bit_not>(), _1);
+} // end operator~()
+
+// there's no standard bit_lshift functional, so roll an ad hoc one here
+struct bit_lshift
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) << THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) << THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) << THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<<(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<<(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<<(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+// there's no standard bit_rshift functional, so roll an ad hoc one here
+struct bit_rshift
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) >> THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >> THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) >> THRUST_FWD(t2);
+  }
+};
+
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>>(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>>(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>>(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5ba77fb48d9bd0a559ea22cce5286471b927053
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h
@@ -0,0 +1,512 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+
+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;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) += THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) += THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) += THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<plus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator+=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<plus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<plus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator+=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<plus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+=()
+
+// there's no standard minus_equal functional, so roll an ad hoc one here
+struct minus_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) -= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) -= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) -= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<minus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator-=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<minus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<minus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator-=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<minus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-=()
+
+// there's no standard multiplies_equal functional, so roll an ad hoc one here
+struct multiplies_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) *= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) *= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) *= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<multiplies_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator*=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<multiplies_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<multiplies_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator*=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<multiplies_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*=()
+
+// there's no standard divides_equal functional, so roll an ad hoc one here
+struct divides_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) /= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) /= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) /= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<divides_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator/=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<divides_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<divides_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator/=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<divides_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/=()
+
+// there's no standard modulus_equal functional, so roll an ad hoc one here
+struct modulus_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) %= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) %= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) %= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<modulus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator%=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<modulus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<modulus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator%=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<modulus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%=()
+
+// there's no standard bit_and_equal functional, so roll an ad hoc one here
+struct bit_and_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) &= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) &= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) &= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_and_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&=()
+
+// there's no standard bit_or_equal functional, so roll an ad hoc one here
+struct bit_or_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) |= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) |= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) |= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator|=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_or_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator|=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+// there's no standard bit_xor_equal functional, so roll an ad hoc one here
+struct bit_xor_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) ^= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) ^= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) ^= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator^=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_xor_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator^=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+// there's no standard bit_lshift_equal functional, so roll an ad hoc one here
+struct bit_lshift_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) <<= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) <<= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) <<= THRUST_FWD(t2);
+  }
+};
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<<=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<<=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<=()
+
+// there's no standard bit_rshift_equal functional, so roll an ad hoc one here
+struct bit_rshift_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) >>= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >>= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) >>= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>>=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>>=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>=()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/logical_operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/logical_operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1e4ff71994c9b7ba18a040933e479fab1864775
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/logical_operators.h
@@ -0,0 +1,143 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&&(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator&&(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&&(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator||(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator||(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator||(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<thrust::logical_not<>>,
+    actor<Eval>
+  >
+>
+operator!(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<thrust::logical_not<>>(), _1);
+} // end operator!()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/operator_adaptors.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/operator_adaptors.h
new file mode 100644
index 0000000000000000000000000000000000000000..67326c5c1e5559130f4f260f665c5e6e8ab33df2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/operator_adaptors.h
@@ -0,0 +1,136 @@
+/*
+ *  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>
+#include <thrust/detail/functional/argument.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/tuple.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/type_traits/void_t.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+// Adapts a transparent unary functor from functional.h (e.g. thrust::negate<>)
+// into the Eval interface.
+template <typename UnaryFunctor>
+struct transparent_unary_operator
+{
+  template <typename>
+  using operator_type = UnaryFunctor;
+
+  template <typename Env>
+  using argument =
+  typename thrust::detail::eval_if<
+    thrust::tuple_size<Env>::value != 1,
+    thrust::detail::identity_<thrust::null_type>,
+    thrust::detail::functional::argument_helper<0, Env>
+  >::type;
+
+  template <typename Env>
+  struct result_type_impl
+  {
+    using type = decltype(
+      std::declval<UnaryFunctor>()(std::declval<argument<Env>>()));
+  };
+
+  template <typename Env>
+  using result_type =
+  typename thrust::detail::eval_if<
+    std::is_same<thrust::null_type, argument<Env>>::value,
+    thrust::detail::identity_<thrust::null_type>,
+    result_type_impl<Env>
+  >::type;
+
+  template <typename Env>
+  struct result
+  {
+    using op_type = UnaryFunctor;
+    using type = result_type<Env>;
+  };
+
+  template <typename Env>
+  __host__ __device__
+  result_type<Env> eval(Env&& e) const
+  THRUST_RETURNS(UnaryFunctor{}(thrust::get<0>(THRUST_FWD(e))))
+};
+
+
+// Adapts a transparent binary functor from functional.h (e.g. thrust::less<>)
+// into the Eval interface.
+template <typename BinaryFunctor>
+struct transparent_binary_operator
+{
+  template <typename>
+  using operator_type = BinaryFunctor;
+
+  template <typename Env>
+  using first_argument =
+    typename thrust::detail::eval_if<
+      thrust::tuple_size<Env>::value != 2,
+      thrust::detail::identity_<thrust::null_type>,
+      thrust::detail::functional::argument_helper<0, Env>
+    >::type;
+
+  template <typename Env>
+  using second_argument =
+    typename thrust::detail::eval_if<
+      thrust::tuple_size<Env>::value != 2,
+      thrust::detail::identity_<thrust::null_type>,
+      thrust::detail::functional::argument_helper<1, Env>
+    >::type;
+
+  template <typename Env>
+  struct result_type_impl
+  {
+    using type = decltype(
+      std::declval<BinaryFunctor>()(std::declval<first_argument<Env>>(),
+                                    std::declval<second_argument<Env>>()));
+  };
+
+  template <typename Env>
+  using result_type =
+    typename thrust::detail::eval_if<
+      (std::is_same<thrust::null_type, first_argument<Env>>::value ||
+       std::is_same<thrust::null_type, second_argument<Env>>::value),
+      thrust::detail::identity_<thrust::null_type>,
+      result_type_impl<Env>
+    >::type;
+
+  template <typename Env>
+  struct result
+  {
+    using op_type = BinaryFunctor;
+    using type = result_type<Env>;
+  };
+
+  template <typename Env>
+  __host__ __device__
+  result_type<Env> eval(Env&& e) const
+  THRUST_RETURNS(BinaryFunctor{}(thrust::get<0>(e), thrust::get<1>(e)))
+};
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/relational_operators.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/relational_operators.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c58325e22513a0ede6d2532c38009ce2736cf98
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/operators/relational_operators.h
@@ -0,0 +1,322 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator==(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator==(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator==(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator!=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator!=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator!=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/placeholder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/placeholder.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3c0835531f063fb53be62f77ad12c7e83b52ec8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/placeholder.h
@@ -0,0 +1,38 @@
+/*
+ *  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>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/argument.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<unsigned int i>
+  struct placeholder
+{
+  typedef actor<argument<i> > type;
+};
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/value.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6b1563b15c5fdc8ae18ec6f7c33a395cb4d9a1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/functional/value.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.
+ */
+
+// 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>
+#include <thrust/detail/functional/actor.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+
+template<typename Eval> struct actor;
+
+
+template<typename T>
+  class value
+{
+  public:
+
+    template<typename Env>
+      struct result
+    {
+      typedef T type;
+    };
+
+    __host__ __device__
+    value(const T &arg)
+      : m_val(arg)
+    {}
+
+    template<typename Env>
+    __host__ __device__
+      T eval(const Env &) const
+    {
+      return m_val;
+    }
+
+  private:
+    T m_val;
+}; // end value
+
+template<typename T>
+__host__ __device__
+actor<value<T> > val(const T &x)
+{
+  return value<T>(x);
+} // end val()
+
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/gather.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/gather.inl
new file mode 100644
index 0000000000000000000000000000000000000000..3812702f61c6e28406d9aaf3091506c30ddc946c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/gather.inl
@@ -0,0 +1,161 @@
+/*
+ *  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>
+
+#include <thrust/gather.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/gather.h>
+#include <thrust/system/detail/adl/gather.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator                                               map_first,
+                        InputIterator                                               map_last,
+                        RandomAccessIterator                                        input_first,
+                        OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::gather;
+  return gather(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, input_first, result);
+} // end gather()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::gather_if;
+  return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result);
+} // end gather_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result,
+                           Predicate                                                   pred)
+{
+  using thrust::system::detail::generic::gather_if;
+  return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result, pred);
+} // end gather_if()
+
+
+template<typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather(InputIterator        map_first,
+                        InputIterator        map_last,
+                        RandomAccessIterator input_first,
+                        OutputIterator       result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type        System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::gather(select_system(system1,system2,system3), map_first, map_last, input_first, result);
+} // end gather()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result);
+} // end gather_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result,
+                           Predicate            pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result, pred);
+} // end gather_if()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/generate.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/generate.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2ecb65d5843b50149883c671283665d6931b6618
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/generate.inl
@@ -0,0 +1,92 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/generate.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/generate.h>
+#include <thrust/system/detail/adl/generate.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Generator>
+__host__ __device__
+  void generate(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                Generator gen)
+{
+  using thrust::system::detail::generic::generate;
+  return generate(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, gen);
+} // end generate()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename OutputIterator,
+         typename Size,
+         typename Generator>
+__host__ __device__
+  OutputIterator generate_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            OutputIterator first,
+                            Size n,
+                            Generator gen)
+{
+  using thrust::system::detail::generic::generate_n;
+  return generate_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, gen);
+} // end generate_n()
+
+
+template<typename ForwardIterator,
+         typename Generator>
+  void generate(ForwardIterator first,
+                ForwardIterator last,
+                Generator gen)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::generate(select_system(system), first, last, gen);
+} // end generate()
+
+
+template<typename OutputIterator,
+         typename Size,
+         typename Generator>
+  OutputIterator generate_n(OutputIterator first,
+                            Size n,
+                            Generator gen)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<OutputIterator>::type System;
+
+  System system;
+
+  return thrust::generate_n(select_system(system), first, n, gen);
+} // end generate_n()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/get_iterator_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/get_iterator_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..27e0a4e47a0b08a9e52869491e0de7aaf451f5e3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/get_iterator_value.h
@@ -0,0 +1,55 @@
+#pragma once
+/*
+ *  Copyright 2008-2016 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.
+ */
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/execution_policy.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/system/detail/generic/memory.h> // for get_value()
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail {
+
+// get_iterator_value specialization on iterators
+// --------------------------------------------------
+// it is okay to dereference iterator in the usual way
+template<typename DerivedPolicy, typename Iterator>
+__host__ __device__
+typename thrust::iterator_traits<Iterator>::value_type
+get_iterator_value(thrust::execution_policy<DerivedPolicy> &, Iterator it)
+{
+  return *it;
+} // get_iterator_value(exec,Iterator);
+
+// get_iterator_value specialization on pointer
+// ----------------------------------------------
+// we can't just dereference a pointer in the usual way, because
+// it may point to a location in the device memory. 
+// we use get_value(exec,pointer*) function
+// to perform a dereferencing consistent with the execution policy
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+typename thrust::detail::pointer_traits<Pointer*>::element_type 
+get_iterator_value(thrust::execution_policy<DerivedPolicy> &exec, Pointer* ptr)
+{
+  return get_value(derived_cast(exec),ptr);
+} // get_iterator_value(exec,Pointer*)
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/inner_product.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/inner_product.inl
new file mode 100644
index 0000000000000000000000000000000000000000..97cd2b0b52e6c4e3bb749b19b50c850a8b76043f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/inner_product.inl
@@ -0,0 +1,101 @@
+/*
+ *  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>
+#include <thrust/inner_product.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/inner_product.h>
+#include <thrust/system/detail/adl/inner_product.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputType>
+__host__ __device__
+OutputType inner_product(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first1,
+                         InputIterator1 last1,
+                         InputIterator2 first2,
+                         OutputType init)
+{
+  using thrust::system::detail::generic::inner_product;
+  return inner_product(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, init);
+} // end inner_product()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputType,
+         typename BinaryFunction1,
+         typename BinaryFunction2>
+__host__ __device__
+OutputType inner_product(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first1,
+                         InputIterator1 last1,
+                         InputIterator2 first2,
+                         OutputType init,
+                         BinaryFunction1 binary_op1,
+                         BinaryFunction2 binary_op2)
+{
+  using thrust::system::detail::generic::inner_product;
+  return inner_product(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, init, binary_op1, binary_op2);
+} // end inner_product()
+
+
+template<typename InputIterator1, typename InputIterator2, typename OutputType>
+OutputType
+inner_product(InputIterator1 first1, InputIterator1 last1,
+              InputIterator2 first2, OutputType init)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::inner_product(select_system(system1,system2), first1, last1, first2, init);
+} // end inner_product()
+
+
+template<typename InputIterator1, typename InputIterator2, typename OutputType,
+         typename BinaryFunction1, typename BinaryFunction2>
+OutputType
+inner_product(InputIterator1 first1, InputIterator1 last1,
+              InputIterator2 first2, OutputType init,
+              BinaryFunction1 binary_op1, BinaryFunction2 binary_op2)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::inner_product(select_system(system1,system2), first1, last1, first2, init, binary_op1, binary_op2);
+} // end inner_product()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_math.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_math.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f8c8aac16883cfad91c428a69a32ca696b0fb95
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_math.h
@@ -0,0 +1,152 @@
+/*
+ *  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>
+#include <thrust/detail/type_deduction.h>
+
+#include <nv/target>
+
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename Integer>
+__host__ __device__ __thrust_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>
+__host__ __device__ __thrust_forceinline__
+bool is_power_of_2(Integer x)
+{
+  return 0 == (x & (x - 1));
+}
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+bool is_odd(Integer x)
+{
+  return 1 & x;
+}
+
+template <typename Integer>
+__host__ __device__ __thrust_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>
+__host__ __device__ __thrust_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>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+// FIXME: Should use common_type.
+auto divide_ri(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS((x + (y - 1)) / y)
+#else
+// FIXME: Should use common_type.
+Integer0 divide_ri(Integer0 const x, Integer1 const y)
+{
+  return (x + (y - 1)) / y;
+}
+#endif
+
+// x/y rounding towards zero for integers.
+// Used to determine # of blocks/warps etc.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto divide_rz(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(x / y)
+#else
+// FIXME: Should use common_type.
+Integer0 divide_rz(Integer0 const x, Integer1 const y)
+{
+  return x / y;
+}
+#endif
+
+// Round x towards infinity to the next multiple of y.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto round_i(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(y * divide_ri(x, y))
+#else
+Integer0 round_i(Integer0 const x, Integer1 const y)
+{
+  return y * divide_ri(x, y);
+}
+#endif
+
+// Round x towards 0 to the next multiple of y.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto round_z(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(y * divide_rz(x, y))
+#else
+Integer0 round_z(Integer0 const x, Integer1 const y)
+{
+  return y * divide_rz(x, y);
+}
+#endif
+
+} // end detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..853af20b860d201a87b160c3445e5dc59343ddfc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/integer_traits.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>
+#include <limits>
+#include <limits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename T>
+  class integer_traits
+{
+  public:
+    static constexpr bool is_integral = false;
+};
+
+template<typename T, T min_val, T max_val>
+  class integer_traits_base
+{
+  public:
+    static constexpr bool is_integral = true;
+    static constexpr T const_min = min_val;
+    static constexpr T const_max = max_val;
+};
+
+
+template<>
+  class integer_traits<bool>
+    : public std::numeric_limits<bool>,
+      public integer_traits_base<bool, false, true>
+{};
+
+
+template<>
+  class integer_traits<char>
+    : public std::numeric_limits<char>,
+      public integer_traits_base<char, CHAR_MIN, CHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<signed char>
+    : public std::numeric_limits<signed char>,
+      public integer_traits_base<signed char, SCHAR_MIN, SCHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned char>
+    : public std::numeric_limits<unsigned char>,
+      public integer_traits_base<unsigned char, 0, UCHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<short>
+    : public std::numeric_limits<short>,
+      public integer_traits_base<short, SHRT_MIN, SHRT_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned short>
+    : public std::numeric_limits<unsigned short>,
+      public integer_traits_base<unsigned short, 0, USHRT_MAX>
+{};
+
+
+template<>
+  class integer_traits<int>
+    : public std::numeric_limits<int>,
+      public integer_traits_base<int, INT_MIN, INT_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned int>
+    : public std::numeric_limits<unsigned int>,
+      public integer_traits_base<unsigned int, 0, UINT_MAX>
+{};
+
+
+template<>
+  class integer_traits<long>
+    : public std::numeric_limits<long>,
+      public integer_traits_base<long, LONG_MIN, LONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned long>
+    : public std::numeric_limits<unsigned long>,
+      public integer_traits_base<unsigned long, 0, ULONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<long long>
+    : public std::numeric_limits<long long>,
+      public integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned long long>
+    : public std::numeric_limits<unsigned long long>,
+      public integer_traits_base<unsigned long long, 0, ULLONG_MAX>
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/internal_functional.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/internal_functional.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0c4056febae12bb6a0eb7cb93f93702efa0b723
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/internal_functional.h
@@ -0,0 +1,558 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file internal_functional.inl
+ *  \brief Non-public functionals used to implement algorithm internals.
+ */
+
+#pragma once
+
+#include <thrust/tuple.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/config.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/memory_wrapper.h> // for ::new
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// unary_negate does not need to know argument_type
+template<typename Predicate>
+struct unary_negate
+{
+  typedef bool result_type;
+
+  Predicate pred;
+
+  __host__ __device__
+  explicit unary_negate(const Predicate& pred) : pred(pred) {}
+
+  template <typename T>
+  __host__ __device__
+  bool operator()(const T& x)
+  {
+    return !bool(pred(x));
+  }
+};
+
+// binary_negate does not need to know first_argument_type or second_argument_type
+template<typename Predicate>
+struct binary_negate
+{
+  typedef bool result_type;
+
+  Predicate pred;
+
+  __host__ __device__
+  explicit binary_negate(const Predicate& pred) : pred(pred) {}
+
+  template <typename T1, typename T2>
+  __host__ __device__
+  bool operator()(const T1& x, const T2& y)
+  {
+    return !bool(pred(x,y));
+  }
+};
+
+template<typename Predicate>
+__host__ __device__
+thrust::detail::unary_negate<Predicate> not1(const Predicate &pred)
+{
+  return thrust::detail::unary_negate<Predicate>(pred);
+}
+
+template<typename Predicate>
+__host__ __device__
+thrust::detail::binary_negate<Predicate> not2(const Predicate &pred)
+{
+  return thrust::detail::binary_negate<Predicate>(pred);
+}
+
+
+// convert a predicate to a 0 or 1 integral value
+template<typename Predicate, typename IntegralType>
+struct predicate_to_integral
+{
+  Predicate pred;
+
+  __host__ __device__
+  explicit predicate_to_integral(const Predicate& pred) : pred(pred) {}
+
+  template <typename T>
+  __host__ __device__
+  IntegralType operator()(const T& x)
+  {
+    return pred(x) ? IntegralType(1) : IntegralType(0);
+  }
+};
+
+
+// note that detail::equal_to does not force conversion from T2 -> T1 as equal_to does
+template<typename T1>
+struct equal_to
+{
+  typedef bool result_type;
+
+  template <typename T2>
+  __host__ __device__
+  bool operator()(const T1& lhs, const T2& rhs) const
+  {
+    return lhs == rhs;
+  }
+};
+
+// note that equal_to_value does not force conversion from T2 -> T1 as equal_to does
+template<typename T2>
+struct equal_to_value
+{
+  T2 rhs;
+
+  __host__ __device__
+  equal_to_value(const T2& rhs) : rhs(rhs) {}
+
+  template <typename T1>
+  __host__ __device__
+  bool operator()(const T1& lhs) const
+  {
+    return lhs == rhs;
+  }
+};
+
+template<typename Predicate>
+struct tuple_binary_predicate
+{
+  typedef bool result_type;
+
+  __host__ __device__
+  tuple_binary_predicate(const Predicate& p) : pred(p) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  bool operator()(const Tuple& t) const
+  {
+    return pred(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  mutable Predicate pred;
+};
+
+template<typename Predicate>
+struct tuple_not_binary_predicate
+{
+  typedef bool result_type;
+
+  __host__ __device__
+  tuple_not_binary_predicate(const Predicate& p) : pred(p) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  bool operator()(const Tuple& t) const
+  {
+    return !pred(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  mutable Predicate pred;
+};
+
+template<typename Generator>
+  struct host_generate_functor
+{
+  typedef void result_type;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  host_generate_functor(Generator g)
+    : gen(g) {}
+
+  // operator() does not take an lvalue reference because some iterators
+  // produce temporary proxy references when dereferenced. for example,
+  // consider the temporary tuple of references produced by zip_iterator.
+  // such temporaries cannot bind to an lvalue reference.
+  //
+  // to WAR this, accept a const reference (which is bindable to a temporary),
+  // and const_cast in the implementation.
+  //
+  // XXX change to an rvalue reference upon c++0x (which either a named variable
+  //     or temporary can bind to)
+  template<typename T>
+  __host__
+  void operator()(const T &x)
+  {
+    // we have to be naughty and const_cast this to get it to work
+    T &lvalue = const_cast<T&>(x);
+
+    // this assigns correctly whether x is a true reference or proxy
+    lvalue = gen();
+  }
+
+  Generator gen;
+};
+
+template<typename Generator>
+  struct device_generate_functor
+{
+  typedef void result_type;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  device_generate_functor(Generator g)
+    : gen(g) {}
+
+  // operator() does not take an lvalue reference because some iterators
+  // produce temporary proxy references when dereferenced. for example,
+  // consider the temporary tuple of references produced by zip_iterator.
+  // such temporaries cannot bind to an lvalue reference.
+  //
+  // to WAR this, accept a const reference (which is bindable to a temporary),
+  // and const_cast in the implementation.
+  //
+  // XXX change to an rvalue reference upon c++0x (which either a named variable
+  //     or temporary can bind to)
+  template<typename T>
+  __host__ __device__
+  void operator()(const T &x)
+  {
+    // we have to be naughty and const_cast this to get it to work
+    T &lvalue = const_cast<T&>(x);
+
+    // this assigns correctly whether x is a true reference or proxy
+    lvalue = gen();
+  }
+
+  Generator gen;
+};
+
+template<typename System, typename Generator>
+  struct generate_functor
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+        thrust::detail::identity_<host_generate_functor<Generator> >,
+        thrust::detail::identity_<device_generate_functor<Generator> >
+      >
+{};
+
+
+template<typename ResultType, typename BinaryFunction>
+  struct zipped_binary_op
+{
+  typedef ResultType result_type;
+
+  __host__ __device__
+  zipped_binary_op(BinaryFunction binary_op)
+    : m_binary_op(binary_op) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  inline result_type operator()(Tuple t)
+  {
+    return m_binary_op(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  BinaryFunction m_binary_op;
+};
+
+
+template<typename T>
+  struct is_non_const_reference
+    : thrust::detail::and_<
+        thrust::detail::not_<thrust::detail::is_const<T> >,
+        thrust::detail::or_<thrust::detail::is_reference<T>,
+                            thrust::detail::is_proxy_reference<T> >
+      >
+{};
+
+template<typename T> struct is_tuple_of_iterator_references : thrust::detail::false_type {};
+
+template<typename... Ts>
+  struct is_tuple_of_iterator_references<
+    thrust::detail::tuple_of_iterator_references<
+      Ts...
+    >
+  >
+    : thrust::detail::true_type
+{};
+
+// use this enable_if to avoid assigning to temporaries in the transform functors below
+// XXX revisit this problem with c++11 perfect forwarding
+template<typename T>
+  struct enable_if_non_const_reference_or_tuple_of_iterator_references
+    : thrust::detail::enable_if<
+        is_non_const_reference<T>::value || is_tuple_of_iterator_references<T>::value
+      >
+{};
+
+
+template<typename UnaryFunction>
+  struct unary_transform_functor
+{
+  typedef void result_type;
+
+  UnaryFunction f;
+
+  __host__ __device__
+  unary_transform_functor(UnaryFunction f)
+    : f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<1,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    thrust::get<1>(t) = f(thrust::get<0>(t));
+  }
+};
+
+
+template<typename BinaryFunction>
+  struct binary_transform_functor
+{
+  BinaryFunction f;
+
+  __host__ __device__
+  binary_transform_functor(BinaryFunction f)
+    : f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<2,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    thrust::get<2>(t) = f(thrust::get<0>(t), thrust::get<1>(t));
+  }
+};
+
+
+template<typename UnaryFunction, typename Predicate>
+struct unary_transform_if_functor
+{
+  UnaryFunction unary_op;
+  Predicate pred;
+
+  __host__ __device__
+  unary_transform_if_functor(UnaryFunction unary_op, Predicate pred)
+    : unary_op(unary_op), pred(pred)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<1,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<0>(t)))
+    {
+      thrust::get<1>(t) = unary_op(thrust::get<0>(t));
+    }
+  }
+}; // end unary_transform_if_functor
+
+
+template<typename UnaryFunction, typename Predicate>
+struct unary_transform_if_with_stencil_functor
+{
+  UnaryFunction unary_op;
+  Predicate pred;
+
+  __host__ __device__
+  unary_transform_if_with_stencil_functor(UnaryFunction unary_op, Predicate pred)
+    : unary_op(unary_op), pred(pred)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<2,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<1>(t)))
+      thrust::get<2>(t) = unary_op(thrust::get<0>(t));
+  }
+}; // end unary_transform_if_with_stencil_functor
+
+
+template<typename BinaryFunction, typename Predicate>
+struct binary_transform_if_functor
+{
+  BinaryFunction binary_op;
+  Predicate pred;
+
+  __host__ __device__
+  binary_transform_if_functor(BinaryFunction binary_op, Predicate pred)
+    : binary_op(binary_op), pred(pred) {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<3,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<2>(t)))
+      thrust::get<3>(t) = binary_op(thrust::get<0>(t), thrust::get<1>(t));
+  }
+}; // end binary_transform_if_functor
+
+
+template<typename T>
+  struct host_destroy_functor
+{
+  __host__
+  void operator()(T &x) const
+  {
+    x.~T();
+  } // end operator()()
+}; // end host_destroy_functor
+
+
+template<typename T>
+  struct device_destroy_functor
+{
+  // add __host__ to allow the omp backend to compile with nvcc
+  __host__ __device__
+  void operator()(T &x) const
+  {
+    x.~T();
+  } // end operator()()
+}; // end device_destroy_functor
+
+
+template<typename System, typename T>
+  struct destroy_functor
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+        thrust::detail::identity_<host_destroy_functor<T> >,
+        thrust::detail::identity_<device_destroy_functor<T> >
+      >
+{};
+
+
+template <typename T>
+struct fill_functor
+{
+  T exemplar;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  fill_functor(const T& _exemplar)
+    : exemplar(_exemplar) {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  fill_functor(const fill_functor & other)
+    :exemplar(other.exemplar){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ~fill_functor() {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  T operator()(void) const
+  {
+    return exemplar;
+  }
+};
+
+
+template<typename T>
+  struct uninitialized_fill_functor
+{
+  T exemplar;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  uninitialized_fill_functor(const T & x):exemplar(x){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  uninitialized_fill_functor(const uninitialized_fill_functor & other)
+    :exemplar(other.exemplar){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ~uninitialized_fill_functor() {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void operator()(T &x)
+  {
+    ::new(static_cast<void*>(&x)) T(exemplar);
+  } // end operator()()
+}; // end uninitialized_fill_functor
+
+
+// this predicate tests two two-element tuples
+// we first use a Compare for the first element
+// if the first elements are equivalent, we use
+// < for the second elements
+template<typename Compare>
+  struct compare_first_less_second
+{
+  compare_first_less_second(Compare c)
+    : comp(c) {}
+
+  template<typename T1, typename T2>
+  __host__ __device__
+  bool operator()(T1 lhs, T2 rhs)
+  {
+    return comp(thrust::get<0>(lhs), thrust::get<0>(rhs)) || (!comp(thrust::get<0>(rhs), thrust::get<0>(lhs)) && thrust::get<1>(lhs) < thrust::get<1>(rhs));
+  }
+
+  Compare comp;
+}; // end compare_first_less_second
+
+
+template<typename Compare>
+  struct compare_first
+{
+  Compare comp;
+
+  __host__ __device__
+  compare_first(Compare comp)
+    : comp(comp)
+  {}
+
+  template<typename Tuple1, typename Tuple2>
+  __host__ __device__
+  bool operator()(const Tuple1 &x, const Tuple2 &y)
+  {
+    return comp(thrust::raw_reference_cast(thrust::get<0>(x)), thrust::raw_reference_cast(thrust::get<0>(y)));
+  }
+}; // end compare_first
+
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/logical.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/logical.inl
new file mode 100644
index 0000000000000000000000000000000000000000..3d39cac926893040c41e2aeb2b03e9e09fa76668
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/logical.inl
@@ -0,0 +1,95 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/logical.h>
+#include <thrust/system/detail/adl/logical.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__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;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::none_of(select_system(system), first, last, pred);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/malloc_and_free.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/malloc_and_free.h
new file mode 100644
index 0000000000000000000000000000000000000000..14351889319888467694bb9b7689325a89a365e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/malloc_and_free.h
@@ -0,0 +1,83 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/detail/generic/memory.h>
+#include <thrust/system/detail/adl/malloc_and_free.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy>
+__host__ __device__
+pointer<void,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, std::size_t n)
+{
+  using thrust::system::detail::generic::malloc;
+
+  // XXX should use a hypothetical thrust::static_pointer_cast here
+  void *raw_ptr = static_cast<void*>(thrust::raw_pointer_cast(malloc(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n)));
+
+  return pointer<void,DerivedPolicy>(raw_ptr);
+}
+
+__thrust_exec_check_disable__
+template<typename T, typename DerivedPolicy>
+__host__ __device__
+pointer<T,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, std::size_t n)
+{
+  using thrust::system::detail::generic::malloc;
+
+  T *raw_ptr = static_cast<T*>(thrust::raw_pointer_cast(malloc<T>(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n)));
+
+  return pointer<T,DerivedPolicy>(raw_ptr);
+}
+
+
+// XXX WAR nvbug 992955
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#if CUDART_VERSION < 5000
+
+// cudafe generates unqualified calls to free(int *volatile)
+// which get confused with thrust::free
+// spoof a thrust::free which simply maps to ::free
+inline __host__ __device__
+void free(int *volatile ptr)
+{
+  ::free(ptr);
+}
+
+#endif // CUDART_VERSION
+#endif // THRUST_DEVICE_COMPILER
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+void free(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, Pointer ptr)
+{
+  using thrust::system::detail::generic::free;
+
+  free(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), ptr);
+}
+
+// XXX consider another form of free which does not take a system argument and
+// instead infers the system from the pointer
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_algorithms.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_algorithms.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f6b3a81d71c22a08025505b1d5c39b4641d78fe
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_algorithms.h
@@ -0,0 +1,237 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+// TODO: These need to be turned into proper Thrust algorithms (dispatch layer,
+// backends, etc).
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/addressof.h>
+
+#include <nv/target>
+
+#include <utility>
+#include <new>
+
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+__host__ __device__
+void destroy_at(T* location)
+{
+  location->~T();
+}
+
+template <typename Allocator, typename T>
+__host__ __device__
+void destroy_at(Allocator const& alloc, T* location)
+{
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  traits::destroy(alloc_T, location);
+}
+
+template <typename ForwardIt>
+__host__ __device__
+ForwardIt destroy(ForwardIt first, ForwardIt last)
+{
+  for (; first != last; ++first)
+    destroy_at(addressof(*first));
+
+  return first;
+}
+
+template <typename Allocator, typename ForwardIt>
+__host__ __device__
+ForwardIt destroy(Allocator const& alloc, ForwardIt first, ForwardIt last)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type T;
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  for (; first != last; ++first)
+    destroy_at(alloc_T, addressof(*first));
+
+  return first;
+}
+
+template <typename ForwardIt, typename Size>
+__host__ __device__
+ForwardIt destroy_n(ForwardIt first, Size n)
+{
+  for (; n > 0; (void) ++first, --n)
+    destroy_at(addressof(*first));
+
+  return first;
+}
+
+template <typename Allocator, typename ForwardIt, typename Size>
+__host__ __device__
+ForwardIt destroy_n(Allocator const& alloc, ForwardIt first, Size n)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type T;
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  for (; n > 0; (void) ++first, --n)
+    destroy_at(alloc_T, addressof(*first));
+
+  return first;
+}
+
+template <typename ForwardIt, typename... Args>
+__host__ __device__
+void uninitialized_construct(
+  ForwardIt first, ForwardIt last, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; current != last; ++current)
+      {
+        ::new (static_cast<void*>(addressof(*current))) T(args...);
+      }
+    } catch (...) {
+      destroy(first, current);
+      throw;
+    }
+  ), (
+    for (; current != last; ++current)
+    {
+      ::new (static_cast<void*>(addressof(*current))) T(args...);
+    }
+  ));
+}
+
+template <typename Allocator, typename ForwardIt, typename... Args>
+void uninitialized_construct_with_allocator(
+  Allocator const& alloc, ForwardIt first, ForwardIt last, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; current != last; ++current)
+      {
+        traits::construct(alloc_T, addressof(*current), args...);
+      }
+    } catch (...) {
+      destroy(alloc_T, first, current);
+      throw;
+    }
+  ), (
+    for (; current != last; ++current)
+    {
+      traits::construct(alloc_T, addressof(*current), args...);
+    }
+  ));
+}
+
+template <typename ForwardIt, typename Size, typename... Args>
+void uninitialized_construct_n(
+  ForwardIt first, Size n, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; n > 0; ++current, --n)
+      {
+        ::new (static_cast<void*>(addressof(*current))) T(args...);
+      }
+    } catch (...) {
+      destroy(first, current);
+      throw;
+    }
+  ), (
+    for (; n > 0; ++current, --n)
+    {
+      ::new (static_cast<void*>(addressof(*current))) T(args...);
+    }
+  ));
+}
+
+template <typename Allocator, typename ForwardIt, typename Size, typename... Args>
+void uninitialized_construct_n_with_allocator(
+  Allocator const& alloc, ForwardIt first, Size n, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; n > 0; (void) ++current, --n)
+      {
+        traits::construct(alloc_T, addressof(*current), args...);
+      }
+    } catch (...) {
+      destroy(alloc_T, first, current);
+      throw;
+    }
+  ), (
+    for (; n > 0; (void) ++current, --n)
+    {
+      traits::construct(alloc_T, addressof(*current), args...);
+    }
+  ));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfc9056fa15ff6d123659499e5fb9044f937f769
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/memory_wrapper.h
@@ -0,0 +1,30 @@
+/*
+ *  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
+
+// 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.  (<memory> declares several standard
+// algorithms, including all of the uninitialized_* algorithms.  "_ALGORITHMS_"
+// in the macro name is meant generically, not as a specific reference to
+// the header <algorithms>.)
+
+#define THRUST_INCLUDING_ALGORITHMS_HEADER
+#include <memory>
+#undef  THRUST_INCLUDING_ALGORITHMS_HEADER
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/merge.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/merge.inl
new file mode 100644
index 0000000000000000000000000000000000000000..1595cc1a145e550a8948c05986e22125789ad749
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/merge.inl
@@ -0,0 +1,221 @@
+/*
+ *  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>
+
+#include <thrust/merge.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/merge.h>
+#include <thrust/system/detail/adl/merge.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result)
+{
+  using thrust::system::detail::generic::merge;
+  return merge(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end merge()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakCompare comp)
+{
+  using thrust::system::detail::generic::merge;
+  return merge(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end merge()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::merge_by_key;
+  return merge_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end merge_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename Compare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 Compare comp)
+{
+  using thrust::system::detail::generic::merge_by_key;
+  return merge_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end merge_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::merge(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end merge()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::merge(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end merge()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1,
+                 InputIterator1 keys_last1,
+                 InputIterator2 keys_first2,
+                 InputIterator2 keys_last2,
+                 InputIterator3 values_first1,
+                 InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::merge_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end merge_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1,
+                 InputIterator1 keys_last1,
+                 InputIterator2 keys_first2,
+                 InputIterator2 keys_last2,
+                 InputIterator3 values_first1,
+                 InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::merge_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end merge_by_key()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/minmax.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/minmax.h
new file mode 100644
index 0000000000000000000000000000000000000000..c565a74bdffba6d20db5a62cc86a3c7889f630c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/minmax.h
@@ -0,0 +1,51 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename T, typename BinaryPredicate>
+__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>
+__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>
+__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>
+__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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mismatch.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mismatch.inl
new file mode 100644
index 0000000000000000000000000000000000000000..16c579d80697b3cac7270b50214c69b04fa4de61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mismatch.inl
@@ -0,0 +1,89 @@
+/*
+ *  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>
+#include <thrust/mismatch.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/mismatch.h>
+#include <thrust/system/detail/adl/mismatch.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+thrust::pair<InputIterator1, InputIterator2> mismatch(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                                      InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2)
+{
+  using thrust::system::detail::generic::mismatch;
+  return mismatch(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2);
+} // end mismatch()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<InputIterator1, InputIterator2> mismatch(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                                      InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2,
+                                                      BinaryPredicate pred)
+{
+  using thrust::system::detail::generic::mismatch;
+  return mismatch(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, pred);
+} // end mismatch()
+
+
+template<typename InputIterator1, typename InputIterator2>
+thrust::pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::mismatch(select_system(system1,system2), first1, last1, first2);
+} // end mismatch()
+
+
+template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+thrust::pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2,
+                                                      BinaryPredicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::mismatch(select_system(system1,system2), first1, last1, first2, pred);
+} // end mismatch()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/modern_gcc_required.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/modern_gcc_required.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8c3d98ba996eec9d6b010dabad65d2261d7e7bc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/modern_gcc_required.h
@@ -0,0 +1,26 @@
+/*
+ *  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/cpp_dialect.h>
+
+#ifndef THRUST_MODERN_GCC_REQUIRED_NO_ERROR
+#  if defined(THRUST_GCC_VERSION) && !defined(THRUST_MODERN_GCC)
+#    error GCC 5 or later is required for this Thrust feature; please upgrade your compiler.
+#  endif
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mpl/math.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mpl/math.h
new file mode 100644
index 0000000000000000000000000000000000000000..bda98003cd5894617a468c3dfab42765375a66fd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/mpl/math.h
@@ -0,0 +1,175 @@
+/*
+ *  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>
+
+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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..e728adcaf3e8c19fa6db82cba94d564dbb5d5dbf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_traits.h
@@ -0,0 +1,129 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <limits>
+
+//#include <stdint.h> // for intmax_t (not provided on MSVS 2005)
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// XXX good enough for the platforms we care about
+typedef long long intmax_t;
+
+template<typename Number>
+  struct is_signed
+    : integral_constant<bool, std::numeric_limits<Number>::is_signed>
+{}; // end is_signed
+
+
+template<typename T>
+  struct num_digits
+    : eval_if<
+        std::numeric_limits<T>::is_specialized,
+        integral_constant<
+          int,
+          std::numeric_limits<T>::digits
+        >,
+        integral_constant<
+          int,
+          sizeof(T) * std::numeric_limits<unsigned char>::digits - (is_signed<T>::value ? 1 : 0)  
+        >
+      >::type
+{}; // end num_digits
+
+
+template<typename Integer>
+  struct integer_difference
+    //: eval_if<
+    //    sizeof(Integer) >= sizeof(intmax_t),
+    //    eval_if<
+    //      is_signed<Integer>::value,
+    //      identity_<Integer>,
+    //      identity_<intmax_t>
+    //    >,
+    //    eval_if<
+    //      sizeof(Integer) < sizeof(std::ptrdiff_t),
+    //      identity_<std::ptrdiff_t>,
+    //      identity_<intmax_t>
+    //    >
+    //  >
+{
+  private:
+    // XXX workaround a pedantic warning in old versions of g++
+    //     which complains about &&ing with a constant value
+    template<bool x, bool y>
+      struct and_
+    {
+      static const bool value = false;
+    };
+
+    template<bool y>
+      struct and_<true,y>
+    {
+      static const bool value = y;
+    };
+
+  public:
+    typedef typename
+      eval_if<
+        and_<
+          std::numeric_limits<Integer>::is_signed,
+          // digits is the number of no-sign bits
+          (!std::numeric_limits<Integer>::is_bounded || (int(std::numeric_limits<Integer>::digits) + 1 >= num_digits<intmax_t>::value))
+        >::value,
+        identity_<Integer>,
+        eval_if<
+          int(std::numeric_limits<Integer>::digits) + 1 < num_digits<signed int>::value,
+          identity_<signed int>,
+          eval_if<
+            int(std::numeric_limits<Integer>::digits) + 1 < num_digits<signed long>::value,
+            identity_<signed long>,
+            identity_<intmax_t>
+          >
+        >
+      >::type type;
+}; // end integer_difference
+
+
+template<typename Number>
+  struct numeric_difference
+    : eval_if<
+      is_integral<Number>::value,
+      integer_difference<Number>,
+      identity_<Number>
+    >
+{}; // end numeric_difference
+
+
+template<typename Number>
+__host__ __device__
+typename numeric_difference<Number>::type
+numeric_distance(Number x, Number y)
+{
+  typedef typename numeric_difference<Number>::type difference_type;
+  return difference_type(y) - difference_type(x);
+} // end numeric_distance
+
+} // end detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ebc6e23b711bf19fbacf8bff631cede4d0332a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/numeric_wrapper.h
@@ -0,0 +1,27 @@
+/*
+ *  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
+
+// 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 <numeric>
+#undef  THRUST_INCLUDING_ALGORITHMS_HEADER
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/overlapped_copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/overlapped_copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..418497de8db9ca8df0029ec748a51c8dc3f168f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/overlapped_copy.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>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/detail/copy.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator sequential_copy(InputIterator first,
+                                 InputIterator last,
+                                 OutputIterator result)
+{
+  for(; first != last; ++first, ++result)
+  {
+    *result = *first;
+  } // end for
+
+  return result;
+} // end sequential_copy()
+
+
+template<typename BidirectionalIterator1,
+         typename BidirectionalIterator2>
+  BidirectionalIterator2 sequential_copy_backward(BidirectionalIterator1 first,
+                                                  BidirectionalIterator1 last,
+                                                  BidirectionalIterator2 result)
+{
+  // yes, we preincrement
+  // the ranges are open on the right, i.e. [first, last)
+  while(first != last)
+  {
+    *--result = *--last;
+  } // end while
+
+  return result;
+} // end sequential_copy_backward()
+
+
+namespace dispatch
+{
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(thrust::system::cpp::detail::execution_policy<DerivedPolicy> &,
+                                        RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  if(first < last && first <= result && result < last)
+  {
+    // result lies in [first, last)
+    // it's safe to use std::copy_backward here
+    thrust::detail::sequential_copy_backward(first, last, result + (last - first));
+    result += (last - first);
+  } // end if
+  else
+  {
+    // result + (last - first) lies in [first, last)
+    // it's safe to use sequential_copy here
+    result = thrust::detail::sequential_copy(first, last, result);
+  } // end else
+
+  return result;
+} // end overlapped_copy()
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(thrust::execution_policy<DerivedPolicy> &exec,
+                                        RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator1>::type value_type;
+
+  // make a temporary copy of [first,last), and copy into it first
+  thrust::detail::temporary_array<value_type, DerivedPolicy> temp(exec, first, last);
+  return thrust::copy(exec, temp.begin(), temp.end(), result);
+} // end overlapped_copy()
+
+} // end dispatch
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  typedef typename thrust::detail::minimum_system<System1, System2>::type System;
+
+  // XXX presumes System is default constructible
+  System system;
+
+  return thrust::detail::dispatch::overlapped_copy(system, first, last, result);
+} // end overlapped_copy()
+
+} // end detail
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pair.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pair.inl
new file mode 100644
index 0000000000000000000000000000000000000000..4b7dd6eb0fed52c782ef416ad39d67ce659277a3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pair.inl
@@ -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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/pair.h>
+#include <thrust/detail/swap.h>
+#include <thrust/tuple.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename T1, typename T2>
+  __host__ __device__
+  pair<T1,T2>
+    ::pair(void)
+      :first(),second()
+{
+  ;
+} // end pair::pair()
+
+
+template <typename T1, typename T2>
+  __host__ __device__
+  pair<T1,T2>
+    ::pair(const T1 &x, const T2 &y)
+      :first(x),second(y)
+{
+  ;
+} // end pair::pair()
+
+
+template <typename T1, typename T2>
+  template <typename U1, typename U2>
+    __host__ __device__
+    pair<T1,T2>
+      ::pair(const pair<U1,U2> &p)
+        :first(p.first),second(p.second)
+{
+  ;
+} // end pair::pair()
+
+
+template <typename T1, typename T2>
+  template <typename U1, typename U2>
+    __host__ __device__
+    pair<T1,T2>
+      ::pair(const std::pair<U1,U2> &p)
+        :first(p.first),second(p.second)
+{
+  ;
+} // end pair::pair()
+
+
+template<typename T1, typename T2>
+  inline __host__ __device__
+    void pair<T1,T2>
+      ::swap(thrust::pair<T1,T2> &p)
+{
+  using thrust::swap;
+
+  swap(first, p.first);
+  swap(second, p.second);
+} // end pair::swap()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator==(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return x.first == y.first && x.second == y.second;
+} // end operator==()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator<(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
+} // end operator<()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator!=(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return !(x == y);
+} // end operator==()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator>(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return y < x;
+} // end operator<()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator<=(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return !(y < x);
+} // end operator<=()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator>=(const pair<T1,T2> &x, const pair<T1,T2> &y)
+{
+  return !(x < y);
+} // end operator>=()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    void swap(pair<T1,T2> &x, pair<T1,T2> &y)
+{
+  return x.swap(y);
+} // end swap()
+
+
+template <typename T1, typename T2>
+  inline __host__ __device__
+    pair<T1,T2> make_pair(T1 x, T2 y)
+{
+  return pair<T1,T2>(x,y);
+} // end make_pair()
+
+
+// specializations of tuple_element for pair
+template<typename T1, typename T2>
+  struct tuple_element<0, pair<T1,T2>>
+{
+  typedef T1 type;
+}; // end tuple_element
+
+template<typename T1, typename T2>
+  struct tuple_element<1, pair<T1,T2>>
+{
+  typedef T2 type;
+}; // end tuple_element
+
+
+// specialization of tuple_size for pair
+template<typename T1, typename T2>
+  struct tuple_size<pair<T1,T2>>
+{
+  static const unsigned int value = 2;
+}; // end tuple_size
+
+
+
+namespace detail
+{
+
+
+template<int N, typename Pair> struct pair_get {};
+
+template<typename Pair>
+  struct pair_get<0, Pair>
+{
+  inline __host__ __device__
+    const typename tuple_element<0, Pair>::type &
+      operator()(const Pair &p) const
+  {
+    return p.first;
+  } // end operator()()
+
+  inline __host__ __device__
+    typename tuple_element<0, Pair>::type &
+      operator()(Pair &p) const
+  {
+    return p.first;
+  } // end operator()()
+}; // end pair_get
+
+
+template<typename Pair>
+  struct pair_get<1, Pair>
+{
+  inline __host__ __device__
+    const typename tuple_element<1, Pair>::type &
+      operator()(const Pair &p) const
+  {
+    return p.second;
+  } // end operator()()
+
+  inline __host__ __device__
+    typename tuple_element<1, Pair>::type &
+      operator()(Pair &p) const
+  {
+    return p.second;
+  } // end operator()()
+}; // end pair_get
+
+} // end detail
+
+
+
+template<unsigned int N, typename T1, typename T2>
+  inline __host__ __device__
+    typename tuple_element<N, pair<T1,T2> >::type &
+      get(pair<T1,T2> &p)
+{
+  return detail::pair_get<N, pair<T1,T2> >()(p);
+} // end get()
+
+template<unsigned int N, typename T1, typename T2>
+  inline __host__ __device__
+    const typename tuple_element<N, pair<T1,T2> >::type &
+      get(const pair<T1,T2> &p)
+{
+  return detail::pair_get<N, pair<T1,T2> >()(p);
+} // end get()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/partition.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/partition.inl
new file mode 100644
index 0000000000000000000000000000000000000000..5c51bca80950681af405ae67b6157e47e13761ed
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/partition.inl
@@ -0,0 +1,411 @@
+/*
+ *  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>
+#include <thrust/partition.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/partition.h>
+#include <thrust/system/detail/adl/partition.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::partition;
+  return partition(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end partition()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::partition;
+  return partition(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, pred);
+} // end partition()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred)
+{
+  using thrust::system::detail::generic::partition_copy;
+  return partition_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, out_true, out_false, pred);
+} // end partition_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator1 first,
+                   InputIterator1 last,
+                   InputIterator2 stencil,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred)
+{
+  using thrust::system::detail::generic::partition_copy;
+  return partition_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, out_true, out_false, pred);
+} // end partition_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred)
+{
+  using thrust::system::detail::generic::stable_partition;
+  return stable_partition(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end stable_partition()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred)
+{
+  using thrust::system::detail::generic::stable_partition;
+  return stable_partition(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, pred);
+} // end stable_partition()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::stable_partition_copy;
+  return stable_partition_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::stable_partition_copy;
+  return stable_partition_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Predicate>
+__host__ __device__
+  ForwardIterator partition_point(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last,
+                                  Predicate pred)
+{
+  using thrust::system::detail::generic::partition_point;
+  return partition_point(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end partition_point()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+  bool is_partitioned(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  using thrust::system::detail::generic::is_partitioned;
+  return is_partitioned(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end is_partitioned()
+
+
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator partition(ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::partition(select_system(system), first, last, pred);
+} // end partition()
+
+
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator partition(ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+  typedef typename thrust::iterator_system<InputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::partition(select_system(system1,system2), first, last, stencil, pred);
+} // end partition()
+
+
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::stable_partition(select_system(system), first, last, pred);
+} // end stable_partition()
+
+
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+  typedef typename thrust::iterator_system<InputIterator>::type   System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::stable_partition(select_system(system1,system2), first, last, stencil, pred);
+} // end stable_partition()
+
+
+template<typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(InputIterator first,
+                   InputIterator last,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::partition_copy(select_system(system1,system2,system3), first, last, out_true, out_false, pred);
+} // end partition_copy()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(InputIterator1 first,
+                   InputIterator1 last,
+                   InputIterator2 stencil,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator1>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::partition_copy(select_system(system1,system2,system3,system4), first, last, stencil, out_true, out_false, pred);
+} // end partition_copy()
+
+
+template<typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::stable_partition_copy(select_system(system1,system2,system3), first, last, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type   System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type   System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type  System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type  System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::stable_partition_copy(select_system(system1,system2,system3,system4), first, last, stencil, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+template<typename ForwardIterator, typename Predicate>
+  ForwardIterator partition_point(ForwardIterator first,
+                                  ForwardIterator last,
+                                  Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::partition_point(select_system(system), first, last, pred);
+} // end partition_point()
+
+
+template<typename InputIterator, typename Predicate>
+  bool is_partitioned(InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::is_partitioned(select_system(system), first, last, pred);
+} // end is_partitioned()
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.h
new file mode 100644
index 0000000000000000000000000000000000000000..aed1fcc2444fae71f3019e8a76ebbc4fd71e30c4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.h
@@ -0,0 +1,255 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/reference_forward_declaration.h>
+#include <ostream>
+#include <cstddef>
+
+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
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::is_void<typename thrust::remove_cvref<Element>::type>::value,
+    thrust::detail::identity_<void>,
+    thrust::detail::remove_cv<Element>
+  >::type value_type;
+
+  // if no Derived type is given, just use pointer
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::is_same<Derived,use_default>::value,
+    thrust::detail::identity_<pointer<Element,Tag,Reference,Derived> >,
+    thrust::detail::identity_<Derived>
+  >::type derived_type;
+
+  // void pointers should have no reference type
+  // if no Reference type is given, just use reference
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::is_void<typename thrust::remove_cvref<Element>::type>::value,
+    thrust::detail::identity_<void>,
+    thrust::detail::eval_if<
+      thrust::detail::is_same<Reference,use_default>::value,
+      thrust::detail::identity_<reference<Element,derived_type> >,
+      thrust::detail::identity_<Reference>
+    >
+  >::type reference_type;
+
+  typedef thrust::iterator_adaptor<
+    derived_type,                        // pass along the type of our Derived class to iterator_adaptor
+    Element *,                           // we adapt a raw pointer
+    value_type,                          // the value type
+    Tag,                                 // system tag
+    thrust::random_access_traversal_tag, // pointers have random access traversal
+    reference_type,                      // pass along our Reference type
+    std::ptrdiff_t
+  > type;
+}; // end pointer_base
+
+
+} // end 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:
+    typedef typename thrust::detail::pointer_base<Element,Tag,Reference,Derived>::type         super_t;
+
+    typedef typename thrust::detail::pointer_base<Element,Tag,Reference,Derived>::derived_type derived_type;
+
+    // friend iterator_core_access to give it access to dereference
+    friend class thrust::iterator_core_access;
+
+    __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:
+    typedef typename super_t::base_type raw_pointer;
+
+    // constructors
+
+    __host__ __device__
+    pointer();
+
+    // NOTE: This is needed so that Thrust smart pointers can be used in
+    // `std::unique_ptr`.
+    __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>
+    __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>
+    __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>
+    __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`.
+    __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>
+    __host__ __device__
+    typename thrust::detail::enable_if_pointer_is_convertible<
+      OtherPointer,
+      pointer,
+      derived_type &
+    >::type
+    operator=(const OtherPointer &other);
+
+    // observers
+
+    __host__ __device__
+    Element *get() const;
+
+    __host__ __device__
+    Element *operator->() const;
+
+    // NOTE: This is needed so that Thrust smart pointers can be used in
+    // `std::unique_ptr`.
+    __host__ __device__
+    explicit operator bool() const;
+
+    __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>
+__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>
+__host__ __device__
+bool operator==(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator==(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator!=(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p);
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator!=(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/pointer.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.inl
new file mode 100644
index 0000000000000000000000000000000000000000..de05ff20f0cc2d0a5bb65ab399c46dd661063016
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/pointer.inl
@@ -0,0 +1,209 @@
+/*
+ *  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>
+
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  pointer<Element,Tag,Reference,Derived>
+    ::pointer()
+      : super_t(static_cast<Element*>(nullptr))
+{} // end pointer::pointer
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  pointer<Element,Tag,Reference,Derived>
+    ::pointer(std::nullptr_t)
+      : super_t(static_cast<Element*>(nullptr))
+{} // end pointer::pointer
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  template<typename OtherElement>
+    __host__ __device__
+    pointer<Element,Tag,Reference,Derived>
+      ::pointer(OtherElement *other)
+        : super_t(other)
+{} // end pointer::pointer
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  template<typename OtherPointer>
+    __host__ __device__
+    pointer<Element,Tag,Reference,Derived>
+      ::pointer(const OtherPointer &other,
+                typename thrust::detail::enable_if_pointer_is_convertible<
+                  OtherPointer,
+                  pointer<Element,Tag,Reference,Derived>
+                 >::type *)
+        : super_t(thrust::detail::pointer_traits<OtherPointer>::get(other))
+{} // end pointer::pointer
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  template<typename OtherPointer>
+    __host__ __device__
+    pointer<Element,Tag,Reference,Derived>
+      ::pointer(const OtherPointer &other,
+                typename thrust::detail::enable_if_void_pointer_is_system_convertible<
+                  OtherPointer,
+                  pointer<Element,Tag,Reference,Derived>
+                 >::type *)
+        : super_t(static_cast<Element *>(thrust::detail::pointer_traits<OtherPointer>::get(other)))
+{} // end pointer::pointer
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  typename pointer<Element,Tag,Reference,Derived>::derived_type &
+    pointer<Element,Tag,Reference,Derived>
+      ::operator=(decltype(nullptr))
+{
+  super_t::base_reference() = nullptr;
+  return static_cast<derived_type&>(*this);
+} // end pointer::operator=
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  template<typename OtherPointer>
+    __host__ __device__
+    typename thrust::detail::enable_if_pointer_is_convertible<
+      OtherPointer,
+      pointer<Element,Tag,Reference,Derived>,
+      typename pointer<Element,Tag,Reference,Derived>::derived_type &
+    >::type
+      pointer<Element,Tag,Reference,Derived>
+        ::operator=(const OtherPointer &other)
+{
+  super_t::base_reference() = thrust::detail::pointer_traits<OtherPointer>::get(other);
+  return static_cast<derived_type&>(*this);
+} // end pointer::operator=
+
+namespace detail
+{
+
+// Implementation for dereference() when Reference is Element&,
+// e.g. cuda's managed_memory_pointer
+template <typename Reference, typename Derived>
+__host__ __device__
+Reference pointer_dereference_impl(const Derived& ptr,
+                                   thrust::detail::true_type /* is_cpp_ref */)
+{
+  return *ptr.get();
+}
+
+// Implementation for pointers with proxy references:
+template <typename Reference, typename Derived>
+__host__ __device__
+Reference pointer_dereference_impl(const Derived& ptr,
+                                   thrust::detail::false_type /* is_cpp_ref */)
+{
+  return Reference(ptr);
+}
+
+} // namespace detail
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  typename pointer<Element,Tag,Reference,Derived>::super_t::reference
+  pointer<Element,Tag,Reference,Derived>
+    ::dereference() const
+{
+  // Need to handle cpp refs and fancy refs differently:
+  typedef typename super_t::reference RefT;
+  typedef typename thrust::detail::is_reference<RefT>::type IsCppRef;
+
+  const derived_type& derivedPtr = static_cast<const derived_type&>(*this);
+
+  return detail::pointer_dereference_impl<RefT>(derivedPtr, IsCppRef());
+} // end pointer::dereference
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  Element *pointer<Element,Tag,Reference,Derived>
+    ::get() const
+{
+  return super_t::base();
+} // end pointer::get
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  Element *pointer<Element,Tag,Reference,Derived>
+    ::operator->() const
+{
+  return super_t::base();
+} // end pointer::operator->
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived>
+  __host__ __device__
+  pointer<Element,Tag,Reference,Derived>
+    ::operator bool() const
+{
+  return bool(get());
+} // end pointer::operator bool
+
+
+template<typename Element, typename Tag, typename Reference, typename Derived,
+         typename charT, typename traits>
+__host__
+std::basic_ostream<charT, traits> &
+operator<<(std::basic_ostream<charT, traits> &os,
+           const pointer<Element, Tag, Reference, Derived> &p) {
+  return os << p.get();
+}
+
+// NOTE: These are needed so that Thrust smart pointers work with
+// `std::unique_ptr`.
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator==(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p)
+{
+  return nullptr == p.get();
+}
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator==(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t)
+{
+  return nullptr == p.get();
+}
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator!=(std::nullptr_t, pointer<Element, Tag, Reference, Derived> p)
+{
+  return !(nullptr == p);
+}
+
+template <typename Element, typename Tag, typename Reference, typename Derived>
+__host__ __device__
+bool operator!=(pointer<Element, Tag, Reference, Derived> p, std::nullptr_t)
+{
+  return !(nullptr == p);
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/preprocessor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/preprocessor.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e850c764dd86591c4ea720b68d2befe11d60aa7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/preprocessor.h
@@ -0,0 +1,1182 @@
+// Copyright (c) 2017-2018 NVIDIA Corporation
+// Copyright (c) 2014-2018 Bryce Adelstein Lelbach
+// Copyright (c) 2001-2015 Housemarque Oy (housemarque.com)
+// Copyright (c) 2007-2015 Hartmut Kaiser
+// Copyright (c)      2002 Peter Dimov and Multi Media Ltd
+//                         (`THRUST_CURRENT_FUNCTION`)
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_PP_STRINGIZE(expr)
+/// \brief Stringizes the expression \a expr.
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << THRUST_PP_STRINGIZE(foo) << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << "foo" << "\n";
+/// }
+/// \endcode
+///
+#define THRUST_PP_STRINGIZE(expr) THRUST_PP_STRINGIZE_IMPL0(expr)
+#define THRUST_PP_STRINGIZE_IMPL0(expr) #expr
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_PP_CAT2(a, b)
+/// \brief Concatenates the tokens \a a and \b b.
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << THRUST_PP_CAT2(1, THRUST_PP_CAT2(2, 3)) << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << 123 << "\n";
+/// }
+/// \endcode
+///
+#define THRUST_PP_CAT2(a, b) THRUST_PP_CAT2_IMPL0(a, b)
+
+#if    defined(_MSC_VER)                                                      \
+  && (defined(__EDG__) || defined(__EDG_VERSION__))                         \
+  && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
+  #define THRUST_PP_CAT2_IMPL0(a, b) THRUST_PP_CAT2_IMPL1(~, a ## b)
+  #define THRUST_PP_CAT2_IMPL1(p, res) res
+#else
+  #define THRUST_PP_CAT2_IMPL0(a, b) a ## b
+#endif
+
+#define THRUST_PP_CAT3(a, b, c)                                               \
+  THRUST_PP_CAT2(a,                                                           \
+    THRUST_PP_CAT2(b, c))                                                     \
+  /**/
+
+#define THRUST_PP_CAT4(a, b, c, d)                                            \
+  THRUST_PP_CAT2(a,                                                           \
+    THRUST_PP_CAT2(b,                                                         \
+      THRUST_PP_CAT2(c, d)))                                                  \
+  /**/
+
+#define THRUST_PP_CAT5(a, b, c, d, e)                                         \
+  THRUST_PP_CAT2(a,                                                           \
+    THRUST_PP_CAT2(b,                                                         \
+      THRUST_PP_CAT2(c,                                                       \
+        THRUST_PP_CAT2(d, e))))                                               \
+  /**/
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_PP_EXPAND(x)
+/// \brief Performs macro expansion on \a x.
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// #define FOO_BAR() "foo_bar"
+/// #define BUZZ()     THRUST_PP_EXPAND(THRUST_PP_CAT2(FOO_, BAR)())
+///
+/// int main()
+/// {
+///   std::cout << BUZZ() << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << "foo_bar" << "\n";
+/// }
+/// \endcode
+///
+#define THRUST_PP_EXPAND(x) THRUST_PP_EXPAND_IMPL0(x)
+#define THRUST_PP_EXPAND_IMPL0(x) x
+
+#define THRUST_PP_EXPAND_ARGS(...) THRUST_PP_EXPAND_ARGS_IMPL0(__VA_ARGS__)
+#define THRUST_PP_EXPAND_ARGS_IMPL0(...) __VA_ARGS__
+
+#define THRUST_PP_HEAD(x, ...) x
+
+#define THRUST_PP_TAIL(x, ...) __VA_ARGS__
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define THRUST_PP_EMPTY()
+
+#define THRUST_PP_COMMA() ,
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define THRUST_PP_INC(x) THRUST_PP_INC_IMPL0(x)
+
+#define THRUST_PP_INC_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_INC_IMPL_TAG, x)
+
+#define THRUST_PP_INC_IMPL_TAG0 1
+#define THRUST_PP_INC_IMPL_TAG1 2
+#define THRUST_PP_INC_IMPL_TAG2 3
+#define THRUST_PP_INC_IMPL_TAG3 4
+#define THRUST_PP_INC_IMPL_TAG4 5
+#define THRUST_PP_INC_IMPL_TAG5 6
+#define THRUST_PP_INC_IMPL_TAG6 7
+#define THRUST_PP_INC_IMPL_TAG7 8
+#define THRUST_PP_INC_IMPL_TAG8 9
+#define THRUST_PP_INC_IMPL_TAG9 10
+#define THRUST_PP_INC_IMPL_TAG10 11
+#define THRUST_PP_INC_IMPL_TAG11 12
+#define THRUST_PP_INC_IMPL_TAG12 13
+#define THRUST_PP_INC_IMPL_TAG13 14
+#define THRUST_PP_INC_IMPL_TAG14 15
+#define THRUST_PP_INC_IMPL_TAG15 16
+#define THRUST_PP_INC_IMPL_TAG16 17
+#define THRUST_PP_INC_IMPL_TAG17 18
+#define THRUST_PP_INC_IMPL_TAG18 19
+#define THRUST_PP_INC_IMPL_TAG19 20
+#define THRUST_PP_INC_IMPL_TAG20 21
+#define THRUST_PP_INC_IMPL_TAG21 22
+#define THRUST_PP_INC_IMPL_TAG22 23
+#define THRUST_PP_INC_IMPL_TAG23 24
+#define THRUST_PP_INC_IMPL_TAG24 25
+#define THRUST_PP_INC_IMPL_TAG25 26
+#define THRUST_PP_INC_IMPL_TAG26 27
+#define THRUST_PP_INC_IMPL_TAG27 28
+#define THRUST_PP_INC_IMPL_TAG28 29
+#define THRUST_PP_INC_IMPL_TAG29 30
+#define THRUST_PP_INC_IMPL_TAG30 31
+#define THRUST_PP_INC_IMPL_TAG31 32
+#define THRUST_PP_INC_IMPL_TAG32 33
+#define THRUST_PP_INC_IMPL_TAG33 34
+#define THRUST_PP_INC_IMPL_TAG34 35
+#define THRUST_PP_INC_IMPL_TAG35 36
+#define THRUST_PP_INC_IMPL_TAG36 37
+#define THRUST_PP_INC_IMPL_TAG37 38
+#define THRUST_PP_INC_IMPL_TAG38 39
+#define THRUST_PP_INC_IMPL_TAG39 40
+#define THRUST_PP_INC_IMPL_TAG40 41
+#define THRUST_PP_INC_IMPL_TAG41 42
+#define THRUST_PP_INC_IMPL_TAG42 43
+#define THRUST_PP_INC_IMPL_TAG43 44
+#define THRUST_PP_INC_IMPL_TAG44 45
+#define THRUST_PP_INC_IMPL_TAG45 46
+#define THRUST_PP_INC_IMPL_TAG46 47
+#define THRUST_PP_INC_IMPL_TAG47 48
+#define THRUST_PP_INC_IMPL_TAG48 49
+#define THRUST_PP_INC_IMPL_TAG49 50
+#define THRUST_PP_INC_IMPL_TAG50 51
+#define THRUST_PP_INC_IMPL_TAG51 52
+#define THRUST_PP_INC_IMPL_TAG52 53
+#define THRUST_PP_INC_IMPL_TAG53 54
+#define THRUST_PP_INC_IMPL_TAG54 55
+#define THRUST_PP_INC_IMPL_TAG55 56
+#define THRUST_PP_INC_IMPL_TAG56 57
+#define THRUST_PP_INC_IMPL_TAG57 58
+#define THRUST_PP_INC_IMPL_TAG58 59
+#define THRUST_PP_INC_IMPL_TAG59 60
+#define THRUST_PP_INC_IMPL_TAG60 61
+#define THRUST_PP_INC_IMPL_TAG61 62
+#define THRUST_PP_INC_IMPL_TAG62 63
+#define THRUST_PP_INC_IMPL_TAG63 64
+#define THRUST_PP_INC_IMPL_TAG64 65
+#define THRUST_PP_INC_IMPL_TAG65 66
+#define THRUST_PP_INC_IMPL_TAG66 67
+#define THRUST_PP_INC_IMPL_TAG67 68
+#define THRUST_PP_INC_IMPL_TAG68 69
+#define THRUST_PP_INC_IMPL_TAG69 70
+#define THRUST_PP_INC_IMPL_TAG70 71
+#define THRUST_PP_INC_IMPL_TAG71 72
+#define THRUST_PP_INC_IMPL_TAG72 73
+#define THRUST_PP_INC_IMPL_TAG73 74
+#define THRUST_PP_INC_IMPL_TAG74 75
+#define THRUST_PP_INC_IMPL_TAG75 76
+#define THRUST_PP_INC_IMPL_TAG76 77
+#define THRUST_PP_INC_IMPL_TAG77 78
+#define THRUST_PP_INC_IMPL_TAG78 79
+#define THRUST_PP_INC_IMPL_TAG79 80
+#define THRUST_PP_INC_IMPL_TAG80 81
+#define THRUST_PP_INC_IMPL_TAG81 82
+#define THRUST_PP_INC_IMPL_TAG82 83
+#define THRUST_PP_INC_IMPL_TAG83 84
+#define THRUST_PP_INC_IMPL_TAG84 85
+#define THRUST_PP_INC_IMPL_TAG85 86
+#define THRUST_PP_INC_IMPL_TAG86 87
+#define THRUST_PP_INC_IMPL_TAG87 88
+#define THRUST_PP_INC_IMPL_TAG88 89
+#define THRUST_PP_INC_IMPL_TAG89 90
+#define THRUST_PP_INC_IMPL_TAG90 91
+#define THRUST_PP_INC_IMPL_TAG91 92
+#define THRUST_PP_INC_IMPL_TAG92 93
+#define THRUST_PP_INC_IMPL_TAG93 94
+#define THRUST_PP_INC_IMPL_TAG94 95
+#define THRUST_PP_INC_IMPL_TAG95 96
+#define THRUST_PP_INC_IMPL_TAG96 97
+#define THRUST_PP_INC_IMPL_TAG97 98
+#define THRUST_PP_INC_IMPL_TAG98 99
+#define THRUST_PP_INC_IMPL_TAG99 100
+#define THRUST_PP_INC_IMPL_TAG100 101
+#define THRUST_PP_INC_IMPL_TAG101 102
+#define THRUST_PP_INC_IMPL_TAG102 103
+#define THRUST_PP_INC_IMPL_TAG103 104
+#define THRUST_PP_INC_IMPL_TAG104 105
+#define THRUST_PP_INC_IMPL_TAG105 106
+#define THRUST_PP_INC_IMPL_TAG106 107
+#define THRUST_PP_INC_IMPL_TAG107 108
+#define THRUST_PP_INC_IMPL_TAG108 109
+#define THRUST_PP_INC_IMPL_TAG109 110
+#define THRUST_PP_INC_IMPL_TAG110 111
+#define THRUST_PP_INC_IMPL_TAG111 112
+#define THRUST_PP_INC_IMPL_TAG112 113
+#define THRUST_PP_INC_IMPL_TAG113 114
+#define THRUST_PP_INC_IMPL_TAG114 115
+#define THRUST_PP_INC_IMPL_TAG115 116
+#define THRUST_PP_INC_IMPL_TAG116 117
+#define THRUST_PP_INC_IMPL_TAG117 118
+#define THRUST_PP_INC_IMPL_TAG118 119
+#define THRUST_PP_INC_IMPL_TAG119 120
+#define THRUST_PP_INC_IMPL_TAG120 121
+#define THRUST_PP_INC_IMPL_TAG121 122
+#define THRUST_PP_INC_IMPL_TAG122 123
+#define THRUST_PP_INC_IMPL_TAG123 124
+#define THRUST_PP_INC_IMPL_TAG124 125
+#define THRUST_PP_INC_IMPL_TAG125 126
+#define THRUST_PP_INC_IMPL_TAG126 127
+#define THRUST_PP_INC_IMPL_TAG127 128
+#define THRUST_PP_INC_IMPL_TAG128 129
+#define THRUST_PP_INC_IMPL_TAG129 130
+#define THRUST_PP_INC_IMPL_TAG130 131
+#define THRUST_PP_INC_IMPL_TAG131 132
+#define THRUST_PP_INC_IMPL_TAG132 133
+#define THRUST_PP_INC_IMPL_TAG133 134
+#define THRUST_PP_INC_IMPL_TAG134 135
+#define THRUST_PP_INC_IMPL_TAG135 136
+#define THRUST_PP_INC_IMPL_TAG136 137
+#define THRUST_PP_INC_IMPL_TAG137 138
+#define THRUST_PP_INC_IMPL_TAG138 139
+#define THRUST_PP_INC_IMPL_TAG139 140
+#define THRUST_PP_INC_IMPL_TAG140 141
+#define THRUST_PP_INC_IMPL_TAG141 142
+#define THRUST_PP_INC_IMPL_TAG142 143
+#define THRUST_PP_INC_IMPL_TAG143 144
+#define THRUST_PP_INC_IMPL_TAG144 145
+#define THRUST_PP_INC_IMPL_TAG145 146
+#define THRUST_PP_INC_IMPL_TAG146 147
+#define THRUST_PP_INC_IMPL_TAG147 148
+#define THRUST_PP_INC_IMPL_TAG148 149
+#define THRUST_PP_INC_IMPL_TAG149 150
+#define THRUST_PP_INC_IMPL_TAG150 151
+#define THRUST_PP_INC_IMPL_TAG151 152
+#define THRUST_PP_INC_IMPL_TAG152 153
+#define THRUST_PP_INC_IMPL_TAG153 154
+#define THRUST_PP_INC_IMPL_TAG154 155
+#define THRUST_PP_INC_IMPL_TAG155 156
+#define THRUST_PP_INC_IMPL_TAG156 157
+#define THRUST_PP_INC_IMPL_TAG157 158
+#define THRUST_PP_INC_IMPL_TAG158 159
+#define THRUST_PP_INC_IMPL_TAG159 160
+#define THRUST_PP_INC_IMPL_TAG160 161
+#define THRUST_PP_INC_IMPL_TAG161 162
+#define THRUST_PP_INC_IMPL_TAG162 163
+#define THRUST_PP_INC_IMPL_TAG163 164
+#define THRUST_PP_INC_IMPL_TAG164 165
+#define THRUST_PP_INC_IMPL_TAG165 166
+#define THRUST_PP_INC_IMPL_TAG166 167
+#define THRUST_PP_INC_IMPL_TAG167 168
+#define THRUST_PP_INC_IMPL_TAG168 169
+#define THRUST_PP_INC_IMPL_TAG169 170
+#define THRUST_PP_INC_IMPL_TAG170 171
+#define THRUST_PP_INC_IMPL_TAG171 172
+#define THRUST_PP_INC_IMPL_TAG172 173
+#define THRUST_PP_INC_IMPL_TAG173 174
+#define THRUST_PP_INC_IMPL_TAG174 175
+#define THRUST_PP_INC_IMPL_TAG175 176
+#define THRUST_PP_INC_IMPL_TAG176 177
+#define THRUST_PP_INC_IMPL_TAG177 178
+#define THRUST_PP_INC_IMPL_TAG178 179
+#define THRUST_PP_INC_IMPL_TAG179 180
+#define THRUST_PP_INC_IMPL_TAG180 181
+#define THRUST_PP_INC_IMPL_TAG181 182
+#define THRUST_PP_INC_IMPL_TAG182 183
+#define THRUST_PP_INC_IMPL_TAG183 184
+#define THRUST_PP_INC_IMPL_TAG184 185
+#define THRUST_PP_INC_IMPL_TAG185 186
+#define THRUST_PP_INC_IMPL_TAG186 187
+#define THRUST_PP_INC_IMPL_TAG187 188
+#define THRUST_PP_INC_IMPL_TAG188 189
+#define THRUST_PP_INC_IMPL_TAG189 190
+#define THRUST_PP_INC_IMPL_TAG190 191
+#define THRUST_PP_INC_IMPL_TAG191 192
+#define THRUST_PP_INC_IMPL_TAG192 193
+#define THRUST_PP_INC_IMPL_TAG193 194
+#define THRUST_PP_INC_IMPL_TAG194 195
+#define THRUST_PP_INC_IMPL_TAG195 196
+#define THRUST_PP_INC_IMPL_TAG196 197
+#define THRUST_PP_INC_IMPL_TAG197 198
+#define THRUST_PP_INC_IMPL_TAG198 199
+#define THRUST_PP_INC_IMPL_TAG199 200
+#define THRUST_PP_INC_IMPL_TAG200 201
+#define THRUST_PP_INC_IMPL_TAG201 202
+#define THRUST_PP_INC_IMPL_TAG202 203
+#define THRUST_PP_INC_IMPL_TAG203 204
+#define THRUST_PP_INC_IMPL_TAG204 205
+#define THRUST_PP_INC_IMPL_TAG205 206
+#define THRUST_PP_INC_IMPL_TAG206 207
+#define THRUST_PP_INC_IMPL_TAG207 208
+#define THRUST_PP_INC_IMPL_TAG208 209
+#define THRUST_PP_INC_IMPL_TAG209 210
+#define THRUST_PP_INC_IMPL_TAG210 211
+#define THRUST_PP_INC_IMPL_TAG211 212
+#define THRUST_PP_INC_IMPL_TAG212 213
+#define THRUST_PP_INC_IMPL_TAG213 214
+#define THRUST_PP_INC_IMPL_TAG214 215
+#define THRUST_PP_INC_IMPL_TAG215 216
+#define THRUST_PP_INC_IMPL_TAG216 217
+#define THRUST_PP_INC_IMPL_TAG217 218
+#define THRUST_PP_INC_IMPL_TAG218 219
+#define THRUST_PP_INC_IMPL_TAG219 220
+#define THRUST_PP_INC_IMPL_TAG220 221
+#define THRUST_PP_INC_IMPL_TAG221 222
+#define THRUST_PP_INC_IMPL_TAG222 223
+#define THRUST_PP_INC_IMPL_TAG223 224
+#define THRUST_PP_INC_IMPL_TAG224 225
+#define THRUST_PP_INC_IMPL_TAG225 226
+#define THRUST_PP_INC_IMPL_TAG226 227
+#define THRUST_PP_INC_IMPL_TAG227 228
+#define THRUST_PP_INC_IMPL_TAG228 229
+#define THRUST_PP_INC_IMPL_TAG229 230
+#define THRUST_PP_INC_IMPL_TAG230 231
+#define THRUST_PP_INC_IMPL_TAG231 232
+#define THRUST_PP_INC_IMPL_TAG232 233
+#define THRUST_PP_INC_IMPL_TAG233 234
+#define THRUST_PP_INC_IMPL_TAG234 235
+#define THRUST_PP_INC_IMPL_TAG235 236
+#define THRUST_PP_INC_IMPL_TAG236 237
+#define THRUST_PP_INC_IMPL_TAG237 238
+#define THRUST_PP_INC_IMPL_TAG238 239
+#define THRUST_PP_INC_IMPL_TAG239 240
+#define THRUST_PP_INC_IMPL_TAG240 241
+#define THRUST_PP_INC_IMPL_TAG241 242
+#define THRUST_PP_INC_IMPL_TAG242 243
+#define THRUST_PP_INC_IMPL_TAG243 244
+#define THRUST_PP_INC_IMPL_TAG244 245
+#define THRUST_PP_INC_IMPL_TAG245 246
+#define THRUST_PP_INC_IMPL_TAG246 247
+#define THRUST_PP_INC_IMPL_TAG247 248
+#define THRUST_PP_INC_IMPL_TAG248 249
+#define THRUST_PP_INC_IMPL_TAG249 250
+#define THRUST_PP_INC_IMPL_TAG250 251
+#define THRUST_PP_INC_IMPL_TAG251 252
+#define THRUST_PP_INC_IMPL_TAG252 253
+#define THRUST_PP_INC_IMPL_TAG253 254
+#define THRUST_PP_INC_IMPL_TAG254 255
+#define THRUST_PP_INC_IMPL_TAG255 256
+#define THRUST_PP_INC_IMPL_TAG256 256
+
+#define THRUST_PP_DEC(x) THRUST_PP_DEC_IMPL0(x)
+
+#define THRUST_PP_DEC_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_DEC_IMPL_TAG, x)
+
+#define THRUST_PP_DEC_IMPL_TAG0 0
+#define THRUST_PP_DEC_IMPL_TAG1 0
+#define THRUST_PP_DEC_IMPL_TAG2 1
+#define THRUST_PP_DEC_IMPL_TAG3 2
+#define THRUST_PP_DEC_IMPL_TAG4 3
+#define THRUST_PP_DEC_IMPL_TAG5 4
+#define THRUST_PP_DEC_IMPL_TAG6 5
+#define THRUST_PP_DEC_IMPL_TAG7 6
+#define THRUST_PP_DEC_IMPL_TAG8 7
+#define THRUST_PP_DEC_IMPL_TAG9 8
+#define THRUST_PP_DEC_IMPL_TAG10 9
+#define THRUST_PP_DEC_IMPL_TAG11 10
+#define THRUST_PP_DEC_IMPL_TAG12 11
+#define THRUST_PP_DEC_IMPL_TAG13 12
+#define THRUST_PP_DEC_IMPL_TAG14 13
+#define THRUST_PP_DEC_IMPL_TAG15 14
+#define THRUST_PP_DEC_IMPL_TAG16 15
+#define THRUST_PP_DEC_IMPL_TAG17 16
+#define THRUST_PP_DEC_IMPL_TAG18 17
+#define THRUST_PP_DEC_IMPL_TAG19 18
+#define THRUST_PP_DEC_IMPL_TAG20 19
+#define THRUST_PP_DEC_IMPL_TAG21 20
+#define THRUST_PP_DEC_IMPL_TAG22 21
+#define THRUST_PP_DEC_IMPL_TAG23 22
+#define THRUST_PP_DEC_IMPL_TAG24 23
+#define THRUST_PP_DEC_IMPL_TAG25 24
+#define THRUST_PP_DEC_IMPL_TAG26 25
+#define THRUST_PP_DEC_IMPL_TAG27 26
+#define THRUST_PP_DEC_IMPL_TAG28 27
+#define THRUST_PP_DEC_IMPL_TAG29 28
+#define THRUST_PP_DEC_IMPL_TAG30 29
+#define THRUST_PP_DEC_IMPL_TAG31 30
+#define THRUST_PP_DEC_IMPL_TAG32 31
+#define THRUST_PP_DEC_IMPL_TAG33 32
+#define THRUST_PP_DEC_IMPL_TAG34 33
+#define THRUST_PP_DEC_IMPL_TAG35 34
+#define THRUST_PP_DEC_IMPL_TAG36 35
+#define THRUST_PP_DEC_IMPL_TAG37 36
+#define THRUST_PP_DEC_IMPL_TAG38 37
+#define THRUST_PP_DEC_IMPL_TAG39 38
+#define THRUST_PP_DEC_IMPL_TAG40 39
+#define THRUST_PP_DEC_IMPL_TAG41 40
+#define THRUST_PP_DEC_IMPL_TAG42 41
+#define THRUST_PP_DEC_IMPL_TAG43 42
+#define THRUST_PP_DEC_IMPL_TAG44 43
+#define THRUST_PP_DEC_IMPL_TAG45 44
+#define THRUST_PP_DEC_IMPL_TAG46 45
+#define THRUST_PP_DEC_IMPL_TAG47 46
+#define THRUST_PP_DEC_IMPL_TAG48 47
+#define THRUST_PP_DEC_IMPL_TAG49 48
+#define THRUST_PP_DEC_IMPL_TAG50 49
+#define THRUST_PP_DEC_IMPL_TAG51 50
+#define THRUST_PP_DEC_IMPL_TAG52 51
+#define THRUST_PP_DEC_IMPL_TAG53 52
+#define THRUST_PP_DEC_IMPL_TAG54 53
+#define THRUST_PP_DEC_IMPL_TAG55 54
+#define THRUST_PP_DEC_IMPL_TAG56 55
+#define THRUST_PP_DEC_IMPL_TAG57 56
+#define THRUST_PP_DEC_IMPL_TAG58 57
+#define THRUST_PP_DEC_IMPL_TAG59 58
+#define THRUST_PP_DEC_IMPL_TAG60 59
+#define THRUST_PP_DEC_IMPL_TAG61 60
+#define THRUST_PP_DEC_IMPL_TAG62 61
+#define THRUST_PP_DEC_IMPL_TAG63 62
+#define THRUST_PP_DEC_IMPL_TAG64 63
+#define THRUST_PP_DEC_IMPL_TAG65 64
+#define THRUST_PP_DEC_IMPL_TAG66 65
+#define THRUST_PP_DEC_IMPL_TAG67 66
+#define THRUST_PP_DEC_IMPL_TAG68 67
+#define THRUST_PP_DEC_IMPL_TAG69 68
+#define THRUST_PP_DEC_IMPL_TAG70 69
+#define THRUST_PP_DEC_IMPL_TAG71 70
+#define THRUST_PP_DEC_IMPL_TAG72 71
+#define THRUST_PP_DEC_IMPL_TAG73 72
+#define THRUST_PP_DEC_IMPL_TAG74 73
+#define THRUST_PP_DEC_IMPL_TAG75 74
+#define THRUST_PP_DEC_IMPL_TAG76 75
+#define THRUST_PP_DEC_IMPL_TAG77 76
+#define THRUST_PP_DEC_IMPL_TAG78 77
+#define THRUST_PP_DEC_IMPL_TAG79 78
+#define THRUST_PP_DEC_IMPL_TAG80 79
+#define THRUST_PP_DEC_IMPL_TAG81 80
+#define THRUST_PP_DEC_IMPL_TAG82 81
+#define THRUST_PP_DEC_IMPL_TAG83 82
+#define THRUST_PP_DEC_IMPL_TAG84 83
+#define THRUST_PP_DEC_IMPL_TAG85 84
+#define THRUST_PP_DEC_IMPL_TAG86 85
+#define THRUST_PP_DEC_IMPL_TAG87 86
+#define THRUST_PP_DEC_IMPL_TAG88 87
+#define THRUST_PP_DEC_IMPL_TAG89 88
+#define THRUST_PP_DEC_IMPL_TAG90 89
+#define THRUST_PP_DEC_IMPL_TAG91 90
+#define THRUST_PP_DEC_IMPL_TAG92 91
+#define THRUST_PP_DEC_IMPL_TAG93 92
+#define THRUST_PP_DEC_IMPL_TAG94 93
+#define THRUST_PP_DEC_IMPL_TAG95 94
+#define THRUST_PP_DEC_IMPL_TAG96 95
+#define THRUST_PP_DEC_IMPL_TAG97 96
+#define THRUST_PP_DEC_IMPL_TAG98 97
+#define THRUST_PP_DEC_IMPL_TAG99 98
+#define THRUST_PP_DEC_IMPL_TAG100 99
+#define THRUST_PP_DEC_IMPL_TAG101 100
+#define THRUST_PP_DEC_IMPL_TAG102 101
+#define THRUST_PP_DEC_IMPL_TAG103 102
+#define THRUST_PP_DEC_IMPL_TAG104 103
+#define THRUST_PP_DEC_IMPL_TAG105 104
+#define THRUST_PP_DEC_IMPL_TAG106 105
+#define THRUST_PP_DEC_IMPL_TAG107 106
+#define THRUST_PP_DEC_IMPL_TAG108 107
+#define THRUST_PP_DEC_IMPL_TAG109 108
+#define THRUST_PP_DEC_IMPL_TAG110 109
+#define THRUST_PP_DEC_IMPL_TAG111 110
+#define THRUST_PP_DEC_IMPL_TAG112 111
+#define THRUST_PP_DEC_IMPL_TAG113 112
+#define THRUST_PP_DEC_IMPL_TAG114 113
+#define THRUST_PP_DEC_IMPL_TAG115 114
+#define THRUST_PP_DEC_IMPL_TAG116 115
+#define THRUST_PP_DEC_IMPL_TAG117 116
+#define THRUST_PP_DEC_IMPL_TAG118 117
+#define THRUST_PP_DEC_IMPL_TAG119 118
+#define THRUST_PP_DEC_IMPL_TAG120 119
+#define THRUST_PP_DEC_IMPL_TAG121 120
+#define THRUST_PP_DEC_IMPL_TAG122 121
+#define THRUST_PP_DEC_IMPL_TAG123 122
+#define THRUST_PP_DEC_IMPL_TAG124 123
+#define THRUST_PP_DEC_IMPL_TAG125 124
+#define THRUST_PP_DEC_IMPL_TAG126 125
+#define THRUST_PP_DEC_IMPL_TAG127 126
+#define THRUST_PP_DEC_IMPL_TAG128 127
+#define THRUST_PP_DEC_IMPL_TAG129 128
+#define THRUST_PP_DEC_IMPL_TAG130 129
+#define THRUST_PP_DEC_IMPL_TAG131 130
+#define THRUST_PP_DEC_IMPL_TAG132 131
+#define THRUST_PP_DEC_IMPL_TAG133 132
+#define THRUST_PP_DEC_IMPL_TAG134 133
+#define THRUST_PP_DEC_IMPL_TAG135 134
+#define THRUST_PP_DEC_IMPL_TAG136 135
+#define THRUST_PP_DEC_IMPL_TAG137 136
+#define THRUST_PP_DEC_IMPL_TAG138 137
+#define THRUST_PP_DEC_IMPL_TAG139 138
+#define THRUST_PP_DEC_IMPL_TAG140 139
+#define THRUST_PP_DEC_IMPL_TAG141 140
+#define THRUST_PP_DEC_IMPL_TAG142 141
+#define THRUST_PP_DEC_IMPL_TAG143 142
+#define THRUST_PP_DEC_IMPL_TAG144 143
+#define THRUST_PP_DEC_IMPL_TAG145 144
+#define THRUST_PP_DEC_IMPL_TAG146 145
+#define THRUST_PP_DEC_IMPL_TAG147 146
+#define THRUST_PP_DEC_IMPL_TAG148 147
+#define THRUST_PP_DEC_IMPL_TAG149 148
+#define THRUST_PP_DEC_IMPL_TAG150 149
+#define THRUST_PP_DEC_IMPL_TAG151 150
+#define THRUST_PP_DEC_IMPL_TAG152 151
+#define THRUST_PP_DEC_IMPL_TAG153 152
+#define THRUST_PP_DEC_IMPL_TAG154 153
+#define THRUST_PP_DEC_IMPL_TAG155 154
+#define THRUST_PP_DEC_IMPL_TAG156 155
+#define THRUST_PP_DEC_IMPL_TAG157 156
+#define THRUST_PP_DEC_IMPL_TAG158 157
+#define THRUST_PP_DEC_IMPL_TAG159 158
+#define THRUST_PP_DEC_IMPL_TAG160 159
+#define THRUST_PP_DEC_IMPL_TAG161 160
+#define THRUST_PP_DEC_IMPL_TAG162 161
+#define THRUST_PP_DEC_IMPL_TAG163 162
+#define THRUST_PP_DEC_IMPL_TAG164 163
+#define THRUST_PP_DEC_IMPL_TAG165 164
+#define THRUST_PP_DEC_IMPL_TAG166 165
+#define THRUST_PP_DEC_IMPL_TAG167 166
+#define THRUST_PP_DEC_IMPL_TAG168 167
+#define THRUST_PP_DEC_IMPL_TAG169 168
+#define THRUST_PP_DEC_IMPL_TAG170 169
+#define THRUST_PP_DEC_IMPL_TAG171 170
+#define THRUST_PP_DEC_IMPL_TAG172 171
+#define THRUST_PP_DEC_IMPL_TAG173 172
+#define THRUST_PP_DEC_IMPL_TAG174 173
+#define THRUST_PP_DEC_IMPL_TAG175 174
+#define THRUST_PP_DEC_IMPL_TAG176 175
+#define THRUST_PP_DEC_IMPL_TAG177 176
+#define THRUST_PP_DEC_IMPL_TAG178 177
+#define THRUST_PP_DEC_IMPL_TAG179 178
+#define THRUST_PP_DEC_IMPL_TAG180 179
+#define THRUST_PP_DEC_IMPL_TAG181 180
+#define THRUST_PP_DEC_IMPL_TAG182 181
+#define THRUST_PP_DEC_IMPL_TAG183 182
+#define THRUST_PP_DEC_IMPL_TAG184 183
+#define THRUST_PP_DEC_IMPL_TAG185 184
+#define THRUST_PP_DEC_IMPL_TAG186 185
+#define THRUST_PP_DEC_IMPL_TAG187 186
+#define THRUST_PP_DEC_IMPL_TAG188 187
+#define THRUST_PP_DEC_IMPL_TAG189 188
+#define THRUST_PP_DEC_IMPL_TAG190 189
+#define THRUST_PP_DEC_IMPL_TAG191 190
+#define THRUST_PP_DEC_IMPL_TAG192 191
+#define THRUST_PP_DEC_IMPL_TAG193 192
+#define THRUST_PP_DEC_IMPL_TAG194 193
+#define THRUST_PP_DEC_IMPL_TAG195 194
+#define THRUST_PP_DEC_IMPL_TAG196 195
+#define THRUST_PP_DEC_IMPL_TAG197 196
+#define THRUST_PP_DEC_IMPL_TAG198 197
+#define THRUST_PP_DEC_IMPL_TAG199 198
+#define THRUST_PP_DEC_IMPL_TAG200 199
+#define THRUST_PP_DEC_IMPL_TAG201 200
+#define THRUST_PP_DEC_IMPL_TAG202 201
+#define THRUST_PP_DEC_IMPL_TAG203 202
+#define THRUST_PP_DEC_IMPL_TAG204 203
+#define THRUST_PP_DEC_IMPL_TAG205 204
+#define THRUST_PP_DEC_IMPL_TAG206 205
+#define THRUST_PP_DEC_IMPL_TAG207 206
+#define THRUST_PP_DEC_IMPL_TAG208 207
+#define THRUST_PP_DEC_IMPL_TAG209 208
+#define THRUST_PP_DEC_IMPL_TAG210 209
+#define THRUST_PP_DEC_IMPL_TAG211 210
+#define THRUST_PP_DEC_IMPL_TAG212 211
+#define THRUST_PP_DEC_IMPL_TAG213 212
+#define THRUST_PP_DEC_IMPL_TAG214 213
+#define THRUST_PP_DEC_IMPL_TAG215 214
+#define THRUST_PP_DEC_IMPL_TAG216 215
+#define THRUST_PP_DEC_IMPL_TAG217 216
+#define THRUST_PP_DEC_IMPL_TAG218 217
+#define THRUST_PP_DEC_IMPL_TAG219 218
+#define THRUST_PP_DEC_IMPL_TAG220 219
+#define THRUST_PP_DEC_IMPL_TAG221 220
+#define THRUST_PP_DEC_IMPL_TAG222 221
+#define THRUST_PP_DEC_IMPL_TAG223 222
+#define THRUST_PP_DEC_IMPL_TAG224 223
+#define THRUST_PP_DEC_IMPL_TAG225 224
+#define THRUST_PP_DEC_IMPL_TAG226 225
+#define THRUST_PP_DEC_IMPL_TAG227 226
+#define THRUST_PP_DEC_IMPL_TAG228 227
+#define THRUST_PP_DEC_IMPL_TAG229 228
+#define THRUST_PP_DEC_IMPL_TAG230 229
+#define THRUST_PP_DEC_IMPL_TAG231 230
+#define THRUST_PP_DEC_IMPL_TAG232 231
+#define THRUST_PP_DEC_IMPL_TAG233 232
+#define THRUST_PP_DEC_IMPL_TAG234 233
+#define THRUST_PP_DEC_IMPL_TAG235 234
+#define THRUST_PP_DEC_IMPL_TAG236 235
+#define THRUST_PP_DEC_IMPL_TAG237 236
+#define THRUST_PP_DEC_IMPL_TAG238 237
+#define THRUST_PP_DEC_IMPL_TAG239 238
+#define THRUST_PP_DEC_IMPL_TAG240 239
+#define THRUST_PP_DEC_IMPL_TAG241 240
+#define THRUST_PP_DEC_IMPL_TAG242 241
+#define THRUST_PP_DEC_IMPL_TAG243 242
+#define THRUST_PP_DEC_IMPL_TAG244 243
+#define THRUST_PP_DEC_IMPL_TAG245 244
+#define THRUST_PP_DEC_IMPL_TAG246 245
+#define THRUST_PP_DEC_IMPL_TAG247 246
+#define THRUST_PP_DEC_IMPL_TAG248 247
+#define THRUST_PP_DEC_IMPL_TAG249 248
+#define THRUST_PP_DEC_IMPL_TAG250 249
+#define THRUST_PP_DEC_IMPL_TAG251 250
+#define THRUST_PP_DEC_IMPL_TAG252 251
+#define THRUST_PP_DEC_IMPL_TAG253 252
+#define THRUST_PP_DEC_IMPL_TAG254 253
+#define THRUST_PP_DEC_IMPL_TAG255 254
+#define THRUST_PP_DEC_IMPL_TAG256 255
+#define THRUST_PP_DEC_IMPL_TAG257 256
+
+#define THRUST_PP_BOOL(x) THRUST_PP_BOOL_IMPL0(x)
+
+#define THRUST_PP_BOOL_IMPL0(x) THRUST_PP_CAT2(THRUST_PP_BOOL_IMPL_TAG, x)
+
+#define THRUST_PP_BOOL_IMPL_TAG0 0
+#define THRUST_PP_BOOL_IMPL_TAG1 1
+#define THRUST_PP_BOOL_IMPL_TAG2 1
+#define THRUST_PP_BOOL_IMPL_TAG3 1
+#define THRUST_PP_BOOL_IMPL_TAG4 1
+#define THRUST_PP_BOOL_IMPL_TAG5 1
+#define THRUST_PP_BOOL_IMPL_TAG6 1
+#define THRUST_PP_BOOL_IMPL_TAG7 1
+#define THRUST_PP_BOOL_IMPL_TAG8 1
+#define THRUST_PP_BOOL_IMPL_TAG9 1
+#define THRUST_PP_BOOL_IMPL_TAG10 1
+#define THRUST_PP_BOOL_IMPL_TAG11 1
+#define THRUST_PP_BOOL_IMPL_TAG12 1
+#define THRUST_PP_BOOL_IMPL_TAG13 1
+#define THRUST_PP_BOOL_IMPL_TAG14 1
+#define THRUST_PP_BOOL_IMPL_TAG15 1
+#define THRUST_PP_BOOL_IMPL_TAG16 1
+#define THRUST_PP_BOOL_IMPL_TAG17 1
+#define THRUST_PP_BOOL_IMPL_TAG18 1
+#define THRUST_PP_BOOL_IMPL_TAG19 1
+#define THRUST_PP_BOOL_IMPL_TAG20 1
+#define THRUST_PP_BOOL_IMPL_TAG21 1
+#define THRUST_PP_BOOL_IMPL_TAG22 1
+#define THRUST_PP_BOOL_IMPL_TAG23 1
+#define THRUST_PP_BOOL_IMPL_TAG24 1
+#define THRUST_PP_BOOL_IMPL_TAG25 1
+#define THRUST_PP_BOOL_IMPL_TAG26 1
+#define THRUST_PP_BOOL_IMPL_TAG27 1
+#define THRUST_PP_BOOL_IMPL_TAG28 1
+#define THRUST_PP_BOOL_IMPL_TAG29 1
+#define THRUST_PP_BOOL_IMPL_TAG30 1
+#define THRUST_PP_BOOL_IMPL_TAG31 1
+#define THRUST_PP_BOOL_IMPL_TAG32 1
+#define THRUST_PP_BOOL_IMPL_TAG33 1
+#define THRUST_PP_BOOL_IMPL_TAG34 1
+#define THRUST_PP_BOOL_IMPL_TAG35 1
+#define THRUST_PP_BOOL_IMPL_TAG36 1
+#define THRUST_PP_BOOL_IMPL_TAG37 1
+#define THRUST_PP_BOOL_IMPL_TAG38 1
+#define THRUST_PP_BOOL_IMPL_TAG39 1
+#define THRUST_PP_BOOL_IMPL_TAG40 1
+#define THRUST_PP_BOOL_IMPL_TAG41 1
+#define THRUST_PP_BOOL_IMPL_TAG42 1
+#define THRUST_PP_BOOL_IMPL_TAG43 1
+#define THRUST_PP_BOOL_IMPL_TAG44 1
+#define THRUST_PP_BOOL_IMPL_TAG45 1
+#define THRUST_PP_BOOL_IMPL_TAG46 1
+#define THRUST_PP_BOOL_IMPL_TAG47 1
+#define THRUST_PP_BOOL_IMPL_TAG48 1
+#define THRUST_PP_BOOL_IMPL_TAG49 1
+#define THRUST_PP_BOOL_IMPL_TAG50 1
+#define THRUST_PP_BOOL_IMPL_TAG51 1
+#define THRUST_PP_BOOL_IMPL_TAG52 1
+#define THRUST_PP_BOOL_IMPL_TAG53 1
+#define THRUST_PP_BOOL_IMPL_TAG54 1
+#define THRUST_PP_BOOL_IMPL_TAG55 1
+#define THRUST_PP_BOOL_IMPL_TAG56 1
+#define THRUST_PP_BOOL_IMPL_TAG57 1
+#define THRUST_PP_BOOL_IMPL_TAG58 1
+#define THRUST_PP_BOOL_IMPL_TAG59 1
+#define THRUST_PP_BOOL_IMPL_TAG60 1
+#define THRUST_PP_BOOL_IMPL_TAG61 1
+#define THRUST_PP_BOOL_IMPL_TAG62 1
+#define THRUST_PP_BOOL_IMPL_TAG63 1
+#define THRUST_PP_BOOL_IMPL_TAG64 1
+#define THRUST_PP_BOOL_IMPL_TAG65 1
+#define THRUST_PP_BOOL_IMPL_TAG66 1
+#define THRUST_PP_BOOL_IMPL_TAG67 1
+#define THRUST_PP_BOOL_IMPL_TAG68 1
+#define THRUST_PP_BOOL_IMPL_TAG69 1
+#define THRUST_PP_BOOL_IMPL_TAG70 1
+#define THRUST_PP_BOOL_IMPL_TAG71 1
+#define THRUST_PP_BOOL_IMPL_TAG72 1
+#define THRUST_PP_BOOL_IMPL_TAG73 1
+#define THRUST_PP_BOOL_IMPL_TAG74 1
+#define THRUST_PP_BOOL_IMPL_TAG75 1
+#define THRUST_PP_BOOL_IMPL_TAG76 1
+#define THRUST_PP_BOOL_IMPL_TAG77 1
+#define THRUST_PP_BOOL_IMPL_TAG78 1
+#define THRUST_PP_BOOL_IMPL_TAG79 1
+#define THRUST_PP_BOOL_IMPL_TAG80 1
+#define THRUST_PP_BOOL_IMPL_TAG81 1
+#define THRUST_PP_BOOL_IMPL_TAG82 1
+#define THRUST_PP_BOOL_IMPL_TAG83 1
+#define THRUST_PP_BOOL_IMPL_TAG84 1
+#define THRUST_PP_BOOL_IMPL_TAG85 1
+#define THRUST_PP_BOOL_IMPL_TAG86 1
+#define THRUST_PP_BOOL_IMPL_TAG87 1
+#define THRUST_PP_BOOL_IMPL_TAG88 1
+#define THRUST_PP_BOOL_IMPL_TAG89 1
+#define THRUST_PP_BOOL_IMPL_TAG90 1
+#define THRUST_PP_BOOL_IMPL_TAG91 1
+#define THRUST_PP_BOOL_IMPL_TAG92 1
+#define THRUST_PP_BOOL_IMPL_TAG93 1
+#define THRUST_PP_BOOL_IMPL_TAG94 1
+#define THRUST_PP_BOOL_IMPL_TAG95 1
+#define THRUST_PP_BOOL_IMPL_TAG96 1
+#define THRUST_PP_BOOL_IMPL_TAG97 1
+#define THRUST_PP_BOOL_IMPL_TAG98 1
+#define THRUST_PP_BOOL_IMPL_TAG99 1
+#define THRUST_PP_BOOL_IMPL_TAG100 1
+#define THRUST_PP_BOOL_IMPL_TAG101 1
+#define THRUST_PP_BOOL_IMPL_TAG102 1
+#define THRUST_PP_BOOL_IMPL_TAG103 1
+#define THRUST_PP_BOOL_IMPL_TAG104 1
+#define THRUST_PP_BOOL_IMPL_TAG105 1
+#define THRUST_PP_BOOL_IMPL_TAG106 1
+#define THRUST_PP_BOOL_IMPL_TAG107 1
+#define THRUST_PP_BOOL_IMPL_TAG108 1
+#define THRUST_PP_BOOL_IMPL_TAG109 1
+#define THRUST_PP_BOOL_IMPL_TAG110 1
+#define THRUST_PP_BOOL_IMPL_TAG111 1
+#define THRUST_PP_BOOL_IMPL_TAG112 1
+#define THRUST_PP_BOOL_IMPL_TAG113 1
+#define THRUST_PP_BOOL_IMPL_TAG114 1
+#define THRUST_PP_BOOL_IMPL_TAG115 1
+#define THRUST_PP_BOOL_IMPL_TAG116 1
+#define THRUST_PP_BOOL_IMPL_TAG117 1
+#define THRUST_PP_BOOL_IMPL_TAG118 1
+#define THRUST_PP_BOOL_IMPL_TAG119 1
+#define THRUST_PP_BOOL_IMPL_TAG120 1
+#define THRUST_PP_BOOL_IMPL_TAG121 1
+#define THRUST_PP_BOOL_IMPL_TAG122 1
+#define THRUST_PP_BOOL_IMPL_TAG123 1
+#define THRUST_PP_BOOL_IMPL_TAG124 1
+#define THRUST_PP_BOOL_IMPL_TAG125 1
+#define THRUST_PP_BOOL_IMPL_TAG126 1
+#define THRUST_PP_BOOL_IMPL_TAG127 1
+#define THRUST_PP_BOOL_IMPL_TAG128 1
+#define THRUST_PP_BOOL_IMPL_TAG129 1
+#define THRUST_PP_BOOL_IMPL_TAG130 1
+#define THRUST_PP_BOOL_IMPL_TAG131 1
+#define THRUST_PP_BOOL_IMPL_TAG132 1
+#define THRUST_PP_BOOL_IMPL_TAG133 1
+#define THRUST_PP_BOOL_IMPL_TAG134 1
+#define THRUST_PP_BOOL_IMPL_TAG135 1
+#define THRUST_PP_BOOL_IMPL_TAG136 1
+#define THRUST_PP_BOOL_IMPL_TAG137 1
+#define THRUST_PP_BOOL_IMPL_TAG138 1
+#define THRUST_PP_BOOL_IMPL_TAG139 1
+#define THRUST_PP_BOOL_IMPL_TAG140 1
+#define THRUST_PP_BOOL_IMPL_TAG141 1
+#define THRUST_PP_BOOL_IMPL_TAG142 1
+#define THRUST_PP_BOOL_IMPL_TAG143 1
+#define THRUST_PP_BOOL_IMPL_TAG144 1
+#define THRUST_PP_BOOL_IMPL_TAG145 1
+#define THRUST_PP_BOOL_IMPL_TAG146 1
+#define THRUST_PP_BOOL_IMPL_TAG147 1
+#define THRUST_PP_BOOL_IMPL_TAG148 1
+#define THRUST_PP_BOOL_IMPL_TAG149 1
+#define THRUST_PP_BOOL_IMPL_TAG150 1
+#define THRUST_PP_BOOL_IMPL_TAG151 1
+#define THRUST_PP_BOOL_IMPL_TAG152 1
+#define THRUST_PP_BOOL_IMPL_TAG153 1
+#define THRUST_PP_BOOL_IMPL_TAG154 1
+#define THRUST_PP_BOOL_IMPL_TAG155 1
+#define THRUST_PP_BOOL_IMPL_TAG156 1
+#define THRUST_PP_BOOL_IMPL_TAG157 1
+#define THRUST_PP_BOOL_IMPL_TAG158 1
+#define THRUST_PP_BOOL_IMPL_TAG159 1
+#define THRUST_PP_BOOL_IMPL_TAG160 1
+#define THRUST_PP_BOOL_IMPL_TAG161 1
+#define THRUST_PP_BOOL_IMPL_TAG162 1
+#define THRUST_PP_BOOL_IMPL_TAG163 1
+#define THRUST_PP_BOOL_IMPL_TAG164 1
+#define THRUST_PP_BOOL_IMPL_TAG165 1
+#define THRUST_PP_BOOL_IMPL_TAG166 1
+#define THRUST_PP_BOOL_IMPL_TAG167 1
+#define THRUST_PP_BOOL_IMPL_TAG168 1
+#define THRUST_PP_BOOL_IMPL_TAG169 1
+#define THRUST_PP_BOOL_IMPL_TAG170 1
+#define THRUST_PP_BOOL_IMPL_TAG171 1
+#define THRUST_PP_BOOL_IMPL_TAG172 1
+#define THRUST_PP_BOOL_IMPL_TAG173 1
+#define THRUST_PP_BOOL_IMPL_TAG174 1
+#define THRUST_PP_BOOL_IMPL_TAG175 1
+#define THRUST_PP_BOOL_IMPL_TAG176 1
+#define THRUST_PP_BOOL_IMPL_TAG177 1
+#define THRUST_PP_BOOL_IMPL_TAG178 1
+#define THRUST_PP_BOOL_IMPL_TAG179 1
+#define THRUST_PP_BOOL_IMPL_TAG180 1
+#define THRUST_PP_BOOL_IMPL_TAG181 1
+#define THRUST_PP_BOOL_IMPL_TAG182 1
+#define THRUST_PP_BOOL_IMPL_TAG183 1
+#define THRUST_PP_BOOL_IMPL_TAG184 1
+#define THRUST_PP_BOOL_IMPL_TAG185 1
+#define THRUST_PP_BOOL_IMPL_TAG186 1
+#define THRUST_PP_BOOL_IMPL_TAG187 1
+#define THRUST_PP_BOOL_IMPL_TAG188 1
+#define THRUST_PP_BOOL_IMPL_TAG189 1
+#define THRUST_PP_BOOL_IMPL_TAG190 1
+#define THRUST_PP_BOOL_IMPL_TAG191 1
+#define THRUST_PP_BOOL_IMPL_TAG192 1
+#define THRUST_PP_BOOL_IMPL_TAG193 1
+#define THRUST_PP_BOOL_IMPL_TAG194 1
+#define THRUST_PP_BOOL_IMPL_TAG195 1
+#define THRUST_PP_BOOL_IMPL_TAG196 1
+#define THRUST_PP_BOOL_IMPL_TAG197 1
+#define THRUST_PP_BOOL_IMPL_TAG198 1
+#define THRUST_PP_BOOL_IMPL_TAG199 1
+#define THRUST_PP_BOOL_IMPL_TAG200 1
+#define THRUST_PP_BOOL_IMPL_TAG201 1
+#define THRUST_PP_BOOL_IMPL_TAG202 1
+#define THRUST_PP_BOOL_IMPL_TAG203 1
+#define THRUST_PP_BOOL_IMPL_TAG204 1
+#define THRUST_PP_BOOL_IMPL_TAG205 1
+#define THRUST_PP_BOOL_IMPL_TAG206 1
+#define THRUST_PP_BOOL_IMPL_TAG207 1
+#define THRUST_PP_BOOL_IMPL_TAG208 1
+#define THRUST_PP_BOOL_IMPL_TAG209 1
+#define THRUST_PP_BOOL_IMPL_TAG210 1
+#define THRUST_PP_BOOL_IMPL_TAG211 1
+#define THRUST_PP_BOOL_IMPL_TAG212 1
+#define THRUST_PP_BOOL_IMPL_TAG213 1
+#define THRUST_PP_BOOL_IMPL_TAG214 1
+#define THRUST_PP_BOOL_IMPL_TAG215 1
+#define THRUST_PP_BOOL_IMPL_TAG216 1
+#define THRUST_PP_BOOL_IMPL_TAG217 1
+#define THRUST_PP_BOOL_IMPL_TAG218 1
+#define THRUST_PP_BOOL_IMPL_TAG219 1
+#define THRUST_PP_BOOL_IMPL_TAG220 1
+#define THRUST_PP_BOOL_IMPL_TAG221 1
+#define THRUST_PP_BOOL_IMPL_TAG222 1
+#define THRUST_PP_BOOL_IMPL_TAG223 1
+#define THRUST_PP_BOOL_IMPL_TAG224 1
+#define THRUST_PP_BOOL_IMPL_TAG225 1
+#define THRUST_PP_BOOL_IMPL_TAG226 1
+#define THRUST_PP_BOOL_IMPL_TAG227 1
+#define THRUST_PP_BOOL_IMPL_TAG228 1
+#define THRUST_PP_BOOL_IMPL_TAG229 1
+#define THRUST_PP_BOOL_IMPL_TAG230 1
+#define THRUST_PP_BOOL_IMPL_TAG231 1
+#define THRUST_PP_BOOL_IMPL_TAG232 1
+#define THRUST_PP_BOOL_IMPL_TAG233 1
+#define THRUST_PP_BOOL_IMPL_TAG234 1
+#define THRUST_PP_BOOL_IMPL_TAG235 1
+#define THRUST_PP_BOOL_IMPL_TAG236 1
+#define THRUST_PP_BOOL_IMPL_TAG237 1
+#define THRUST_PP_BOOL_IMPL_TAG238 1
+#define THRUST_PP_BOOL_IMPL_TAG239 1
+#define THRUST_PP_BOOL_IMPL_TAG240 1
+#define THRUST_PP_BOOL_IMPL_TAG241 1
+#define THRUST_PP_BOOL_IMPL_TAG242 1
+#define THRUST_PP_BOOL_IMPL_TAG243 1
+#define THRUST_PP_BOOL_IMPL_TAG244 1
+#define THRUST_PP_BOOL_IMPL_TAG245 1
+#define THRUST_PP_BOOL_IMPL_TAG246 1
+#define THRUST_PP_BOOL_IMPL_TAG247 1
+#define THRUST_PP_BOOL_IMPL_TAG248 1
+#define THRUST_PP_BOOL_IMPL_TAG249 1
+#define THRUST_PP_BOOL_IMPL_TAG250 1
+#define THRUST_PP_BOOL_IMPL_TAG251 1
+#define THRUST_PP_BOOL_IMPL_TAG252 1
+#define THRUST_PP_BOOL_IMPL_TAG253 1
+#define THRUST_PP_BOOL_IMPL_TAG254 1
+#define THRUST_PP_BOOL_IMPL_TAG255 1
+#define THRUST_PP_BOOL_IMPL_TAG256 1
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define THRUST_PP_IIF(bit, t, f) THRUST_PP_IIF_IMPL0(bit, t, f)
+
+#if defined(_MSC_VER)
+  #define THRUST_PP_IIF_IMPL0(bit, t, f)                                      \
+    THRUST_PP_IIF_IMPL1(THRUST_PP_CAT2(THRUST_PP_IIF_IMPL_TAG, bit(t, f)))    \
+    /**/
+  #define THRUST_PP_IIF_IMPL1(id) id
+#else
+  #define THRUST_PP_IIF_IMPL0(bit, t, f)                                      \
+    THRUST_PP_CAT2(THRUST_PP_IIF_IMPL_TAG, bit(t, f))
+    /**/
+#endif
+
+#define THRUST_PP_IIF_IMPL_TAG0(t, f) f
+#define THRUST_PP_IIF_IMPL_TAG1(t, f) t
+
+#if defined(__EDG__)
+  #define THRUST_PP_IF(cond, t, f) THRUST_PP_IF_IMPL0(cond, t, f)
+  #define THRUST_PP_IF_IMPL0(cond, t, f)                                      \
+    THRUST_PP_IIF(THRUST_PP_BOOL(cond), t, f)                                 \
+    /**/
+#else
+  #define THRUST_PP_IF(cond, t, f) THRUST_PP_IIF(THRUST_PP_BOOL(cond), t, f)
+#endif
+
+/// \def THRUST_COMMA_IF(cond)
+/// \brief If \a cond is true, expands to a comma. Otherwise, expands to nothing.
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << THRUST_PP_STRINGIZE(THRUST_COMMA_IF(0)) << "\n"
+///             << THRUST_PP_STRINGIZE(THRUST_COMMA_IF(1)) << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << ""  << "\n"
+///             << "," << "\n";
+/// }
+/// \endcode
+///
+#if defined(__EDG__)
+  #define THRUST_PP_COMMA_IF(cond) THRUST_PP_COMMA_IF_IMPL0(cond)
+  #define THRUST_PP_COMMA_IF_IMPL0(cond)                                      \
+    THRUST_PP_IF(cond, THRUST_PP_COMMA, THRUST_PP_EMPTY)()                    \
+    /**/
+#else
+  #define THRUST_PP_COMMA_IF(cond)                                            \
+    THRUST_PP_IF(cond, THRUST_PP_COMMA, THRUST_PP_EMPTY)()                    \
+    /**/
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+// http://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments
+
+#define THRUST_PP_64TH_ARG(                                                   \
+     _1, _2, _3, _4, _5, _6, _7, _8, _9,_10,_11,_12,_13,_14,_15,_16           \
+  , _17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32           \
+  , _33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48           \
+  , _49,_50,_51,_52,_53,_54,_55,_56,_57,_58,_59,_60,_61,_62,_63,  N           \
+  , ...                                                                       \
+  ) N                                                                         \
+  /**/
+
+#define THRUST_PP_HAS_COMMA(...)                                              \
+  THRUST_PP_EXPAND(THRUST_PP_64TH_ARG(                                        \
+    __VA_ARGS__                                                               \
+  , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1                                           \
+  , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1                                           \
+  , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1                                           \
+  , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0                                             \
+  ))                                                                          \
+  /**/
+
+#define THRUST_PP_TRIGGER_PAREN(...) ,
+
+#define THRUST_PP_IS_VARIADIC_NULLARY(...)                                    \
+  THRUST_PP_IS_VARIADIC_NULLARY_IMPL0(                                        \
+    /* Test if there is just one argument, eventually an empty one. */        \
+    THRUST_PP_HAS_COMMA(__VA_ARGS__),                                         \
+    /* Test if THRUST_PP_TRIGGER_PAREN together with the argument adds a */   \
+    /* comma. */                                                              \
+    THRUST_PP_HAS_COMMA(THRUST_PP_TRIGGER_PAREN __VA_ARGS__),                 \
+    /* Test if the argument together with a parenthesis adds a comma. */      \
+    THRUST_PP_HAS_COMMA(__VA_ARGS__ (/*empty*/)),                             \
+    /* Test if placing it between THRUST_PP_TRIGGER_PAREN and the */          \
+    /* parenthesis adds a comma. */                                           \
+    THRUST_PP_HAS_COMMA(THRUST_PP_TRIGGER_PAREN __VA_ARGS__ (/*empty*/))      \
+  )                                                                           \
+  /**/
+
+#define THRUST_PP_IS_VARIADIC_NULLARY_IMPL0(_0, _1, _2, _3)                   \
+  THRUST_PP_HAS_COMMA(                                                        \
+    THRUST_PP_CAT5(THRUST_PP_IS_VARIADIC_NULLARY_IMPL_TAG, _0, _1, _2, _3)    \
+  )                                                                           \
+
+#define THRUST_PP_IS_VARIADIC_NULLARY_IMPL_TAG0001 ,
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_PP_ARITY(...)
+/// \brief Returns the number of arguments that it was called with. Must be
+///        called with less than 64 arguments.
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << THRUST_PP_ARITY()        << "\n"
+///             << THRUST_PP_ARITY(x)       << "\n"
+///             << THRUST_PP_ARITY(x, y)    << "\n"
+///             << THRUST_PP_ARITY(x, y, z) << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << 0 << "\n"
+///             << 1 << "\n"
+///             << 2 << "\n"
+///             << 3 << "\n";
+/// }
+/// \endcode
+///
+#define THRUST_PP_ARITY(...)                                                  \
+  THRUST_PP_EXPAND(                                                           \
+    THRUST_PP_IF(                                                             \
+      THRUST_PP_IS_VARIADIC_NULLARY(__VA_ARGS__)                              \
+    , 0                                                                       \
+    , THRUST_PP_64TH_ARG(                                                     \
+        __VA_ARGS__                                                           \
+      , 63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48                       \
+      , 47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32                       \
+      , 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16                       \
+      , 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0                       \
+      )                                                                       \
+    )                                                                         \
+  )                                                                           \
+  /**/
+
+/// \def THRUST_PP_DISPATCH(basename, ...)
+/// \brief Expands to <tt>basenameN(...)</tt>, where <tt>N</tt> is the
+///        number of variadic arguments that \a THRUST_PP_DISPATCH was called
+///        with. This macro can be used to implement "macro overloading".
+///
+/// \par <b>Example</b>:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// #define PLUS(...) THRUST_PP_DISPATCH(PLUS, __VA_ARGS__)
+/// #define PLUS0()        0
+/// #define PLUS1(x)       x
+/// #define PLUS2(x, y)    x + y
+/// #define PLUS3(x, y, z) x + y + z
+///
+/// int main()
+/// {
+///   std::cout << PLUS()        << "\n"
+///             << PLUS(1)       << "\n"
+///             << PLUS(1, 2)    << "\n"
+///             << PLUS(1, 2, 3) << "\n";
+/// }
+/// \endcode
+///
+/// The above code expands to:
+///
+/// \code
+/// #include <thrust/detail/preprocessor.h>
+/// #include <iostream>
+///
+/// int main()
+/// {
+///   std::cout << 0         << "\n"
+///             << 1         << "\n"
+///             << 1 + 2     << "\n"
+///             << 1 + 2 + 3 << "\n";
+/// }
+/// \endcode
+///
+#define THRUST_PP_DISPATCH(basename, ...)                                     \
+  THRUST_PP_EXPAND(                                                           \
+    THRUST_PP_CAT2(                                                           \
+      basename,                                                               \
+      THRUST_PP_ARITY(__VA_ARGS__)                                            \
+    )(__VA_ARGS__)                                                            \
+  )                                                                           \
+  /**/
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_CURRENT_FUNCTION
+/// \brief The name of the current function as a string.
+///
+#if    defined(__GNUC__)                                                      \
+    || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000))                        \
+    || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
+  #define THRUST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+  #define THRUST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+#elif defined(__FUNCSIG__)
+  #define THRUST_CURRENT_FUNCTION __FUNCSIG__
+#elif    (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600))             \
+      || (defined(__IBMCTHRUST_PP__) && (__IBMCTHRUST_PP__ >= 500))
+  #define THRUST_CURRENT_FUNCTION __FUNCTION__
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
+  #define THRUST_CURRENT_FUNCTION __FUNC__
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+  #define THRUST_CURRENT_FUNCTION __func__
+#elif defined(__cplusplus) && (__cplusplus >= 201103)
+  #define THRUST_CURRENT_FUNCTION __func__
+#else
+  #define THRUST_CURRENT_FUNCTION "(unknown)"
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/head_flags.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/head_flags.h
new file mode 100644
index 0000000000000000000000000000000000000000..b755840c991654a8baeadbe374d09f120029ae14
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/head_flags.h
@@ -0,0 +1,229 @@
+/*
+ *  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>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/tuple.h>
+#include <thrust/functional.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_with_init
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator>::type init_type;
+
+  // XXX WAR cudafe issue
+  //private:
+  public:
+    struct head_flag_functor
+    {
+      BinaryPredicate binary_pred; // this must be the first member for performance reasons
+      init_type init;
+      IndexType n;
+
+      typedef ValueType result_type;
+
+      __host__ __device__
+      head_flag_functor(init_type init, IndexType n)
+        : binary_pred(), init(init), n(n)
+      {}
+
+      __host__ __device__
+      head_flag_functor(init_type init, IndexType n, BinaryPredicate binary_pred)
+        : binary_pred(binary_pred), init(init), n(n)
+      {}
+
+      template<typename Tuple>
+      __host__ __device__ __thrust_forceinline__
+      result_type operator()(const Tuple &t)
+      {
+        const IndexType i = thrust::get<0>(t);
+
+        if(i == 0)
+        {
+          return !binary_pred(init, thrust::get<1>(t));
+        }
+
+        return !binary_pred(thrust::get<1>(t), thrust::get<2>(t));
+      }
+    };
+
+    typedef thrust::counting_iterator<IndexType> counting_iterator;
+
+  public:
+    typedef thrust::transform_iterator<
+      head_flag_functor,
+      thrust::zip_iterator<thrust::tuple<counting_iterator,RandomAccessIterator,RandomAccessIterator> >
+    > iterator;
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init)
+      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
+                                                head_flag_functor(init, last - first))),
+        m_end(m_begin + (last - first))
+    {}
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    head_flags_with_init(RandomAccessIterator first, RandomAccessIterator last, init_type init, BinaryPredicate binary_pred)
+      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
+                                                head_flag_functor(init, last - first, binary_pred))),
+        m_end(m_begin + (last - first))
+    {}
+
+    __host__ __device__
+    iterator begin() const
+    {
+      return m_begin;
+    }
+
+    __host__ __device__
+    iterator end() const
+    {
+      return m_end;
+    }
+
+    template<typename OtherIndex>
+    __host__ __device__
+    typename iterator::reference operator[](OtherIndex i)
+    {
+      return *(begin() + i);
+    }
+
+  private:
+    iterator m_begin, m_end;
+};
+
+
+
+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
+{
+  // XXX WAR cudafe issue
+  //private:
+  public:
+    struct head_flag_functor
+    {
+      BinaryPredicate binary_pred; // this must be the first member for performance reasons
+      IndexType n;
+
+      typedef ValueType result_type;
+
+      __host__ __device__
+      head_flag_functor(IndexType n)
+        : binary_pred(), n(n)
+      {}
+
+      __host__ __device__
+      head_flag_functor(IndexType n, BinaryPredicate binary_pred)
+        : binary_pred(binary_pred), n(n)
+      {}
+
+      template<typename Tuple>
+      __host__ __device__ __thrust_forceinline__
+      result_type operator()(const Tuple &t)
+      {
+        const IndexType i = thrust::get<0>(t);
+
+        // note that we do not dereference the tuple's 2nd element when i <= 0
+        // and therefore do not dereference a bad location at the boundary
+        return (i == 0 || !binary_pred(thrust::get<1>(t), thrust::get<2>(t)));
+      }
+    };
+
+    typedef thrust::counting_iterator<IndexType> counting_iterator;
+
+  public:
+    typedef thrust::transform_iterator<
+      head_flag_functor,
+      thrust::zip_iterator<thrust::tuple<counting_iterator,RandomAccessIterator,RandomAccessIterator> >
+    > iterator;
+
+    __host__ __device__
+    head_flags(RandomAccessIterator first, RandomAccessIterator last)
+      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
+                                                head_flag_functor(last - first))),
+        m_end(m_begin + (last - first))
+    {}
+
+    __host__ __device__
+    head_flags(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+      : m_begin(thrust::make_transform_iterator(thrust::make_zip_iterator(thrust::make_tuple(thrust::counting_iterator<IndexType>(0), first, first - 1)),
+                                                head_flag_functor(last - first, binary_pred))),
+        m_end(m_begin + (last - first))
+    {}
+
+    __host__ __device__
+    iterator begin() const
+    {
+      return m_begin;
+    }
+
+    __host__ __device__
+    iterator end() const
+    {
+      return m_end;
+    }
+
+    template<typename OtherIndex>
+    __host__ __device__
+    typename iterator::reference operator[](OtherIndex i)
+    {
+      return *(begin() + i);
+    }
+
+  private:
+    iterator m_begin, m_end;
+};
+
+
+template<typename RandomAccessIterator, typename BinaryPredicate>
+__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>
+__host__ __device__
+head_flags<RandomAccessIterator>
+  make_head_flags(RandomAccessIterator first, RandomAccessIterator last)
+{
+  return head_flags<RandomAccessIterator>(first, last);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/tail_flags.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/tail_flags.h
new file mode 100644
index 0000000000000000000000000000000000000000..41ee5dd29cc8cc2a691a6c944ce2a540e7a1ab1e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/range/tail_flags.h
@@ -0,0 +1,133 @@
+/*
+ *  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>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/tuple.h>
+#include <thrust/functional.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;
+
+      typedef ValueType result_type;
+
+      __host__ __device__
+      tail_flag_functor(RandomAccessIterator first, RandomAccessIterator last)
+        : binary_pred(), iter(first), n(last - first)
+      {}
+
+      __host__ __device__
+      tail_flag_functor(RandomAccessIterator first, RandomAccessIterator last, BinaryPredicate binary_pred)
+        : binary_pred(binary_pred), iter(first), n(last - first)
+      {}
+
+      __host__ __device__ __thrust_forceinline__
+      result_type operator()(const IndexType &i)
+      {
+        return (i == (n - 1) || !binary_pred(iter[i], iter[i+1]));
+      }
+    };
+
+    typedef thrust::counting_iterator<IndexType> counting_iterator;
+
+  public:
+    typedef thrust::transform_iterator<
+      tail_flag_functor,
+      counting_iterator
+    > iterator;
+
+    __thrust_exec_check_disable__
+    __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))
+    {}
+
+    __thrust_exec_check_disable__
+    __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))
+    {}
+
+    __host__ __device__
+    iterator begin() const
+    {
+      return m_begin;
+    }
+
+    __host__ __device__
+    iterator end() const
+    {
+      return m_end;
+    }
+
+    template<typename OtherIndex>
+    __host__ __device__
+    typename iterator::reference operator[](OtherIndex i)
+    {
+      return *(begin() + i);
+    }
+
+  private:
+    iterator m_begin, m_end;
+};
+
+
+template<typename RandomAccessIterator, typename BinaryPredicate>
+__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>
+__host__ __device__
+tail_flags<RandomAccessIterator>
+  make_tail_flags(RandomAccessIterator first, RandomAccessIterator last)
+{
+  return tail_flags<RandomAccessIterator>(first, last);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_pointer_cast.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_pointer_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..53a77861ef0eee454da56b90cf4fc4d4955f974c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_pointer_cast.h
@@ -0,0 +1,50 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename Pointer>
+__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>
+__host__ __device__
+ToPointer
+reinterpret_pointer_cast(FromPointer ptr)
+{
+  typedef typename thrust::detail::pointer_element<ToPointer>::type to_element;
+  return ToPointer(reinterpret_cast<to_element*>(thrust::raw_pointer_cast(ptr)));
+}
+
+template <typename ToPointer, typename FromPointer>
+__host__ __device__
+ToPointer
+static_pointer_cast(FromPointer ptr)
+{
+  typedef typename thrust::detail::pointer_element<ToPointer>::type to_element;
+  return ToPointer(static_cast<to_element*>(thrust::raw_pointer_cast(ptr)));
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_reference_cast.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_reference_cast.h
new file mode 100644
index 0000000000000000000000000000000000000000..eff45f0c273b90ae7f835bfeab9b240978cf2f8f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/raw_reference_cast.h
@@ -0,0 +1,332 @@
+/*
+ *  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>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/tuple_transform.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+
+
+// the order of declarations and definitions in this file is totally goofy
+// this header defines raw_reference_cast, which has a few overloads towards the bottom of the file
+// raw_reference_cast depends on metafunctions such as is_unwrappable and raw_reference
+// we need to be sure that these metafunctions are completely defined (including specializations) before they are instantiated by raw_reference_cast
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(is_wrapped_reference, wrapped_reference_hint)
+
+
+// wrapped reference-like things which aren't strictly wrapped references
+// (e.g. tuples of wrapped references) are considered unwrappable
+template<typename T>
+  struct is_unwrappable
+    : is_wrapped_reference<T>
+{};
+
+
+// specialize is_unwrappable
+// a tuple is_unwrappable if any of its elements is_unwrappable
+template<typename... Ts>
+  struct is_unwrappable<
+    thrust::tuple<Ts...>
+  >
+    : or_<
+        is_unwrappable<Ts>...
+      >
+{};
+
+
+// specialize is_unwrappable
+// a tuple_of_iterator_references is_unwrappable if any of its elements is_unwrappable
+template<
+  typename... Ts
+>
+  struct is_unwrappable<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+    : or_<
+        is_unwrappable<Ts>...
+      >
+{};
+
+
+template<typename T, typename Result = void>
+  struct enable_if_unwrappable
+    : enable_if<
+        is_unwrappable<T>::value,
+        Result
+      >
+{};
+
+
+namespace raw_reference_detail
+{
+
+
+template<typename T, typename Enable = void>
+  struct raw_reference_impl
+    : add_reference<T>
+{};
+
+
+template<typename T>
+  struct raw_reference_impl<
+    T,
+    typename thrust::detail::enable_if<
+      is_wrapped_reference<
+        typename remove_cv<T>::type
+      >::value
+    >::type
+  >
+{
+  typedef typename add_reference<
+    typename pointer_element<typename T::pointer>::type
+  >::type type;
+};
+
+
+} // end raw_reference_detail
+
+
+template<typename T>
+  struct raw_reference :
+    raw_reference_detail::raw_reference_impl<T>
+{};
+
+
+namespace raw_reference_detail
+{
+
+// unlike raw_reference,
+// raw_reference_tuple_helper needs to return a value
+// when it encounters one, rather than a reference
+// upon encountering tuple, recurse
+//
+// we want the following behavior:
+//  1. T                                -> T
+//  2. T&                               -> T&
+//  3. null_type                        -> null_type
+//  4. reference<T>                     -> T&
+//  5. tuple_of_iterator_references<T>  -> tuple_of_iterator_references<raw_reference_tuple_helper<T>::type>
+
+
+// wrapped references are unwrapped using raw_reference, otherwise, return T
+template<typename T>
+  struct raw_reference_tuple_helper
+    : eval_if<
+        is_unwrappable<
+          typename remove_cv<T>::type
+        >::value,
+        raw_reference<T>,
+        identity_<T>
+      >
+{};
+
+
+// recurse on tuples
+template <
+  typename... Ts
+>
+  struct raw_reference_tuple_helper<
+    thrust::tuple<Ts...>
+  >
+{
+  typedef thrust::tuple<
+    typename raw_reference_tuple_helper<Ts>::type...
+  > type;
+};
+
+
+template <
+  typename... Ts
+>
+  struct raw_reference_tuple_helper<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+{
+  typedef thrust::detail::tuple_of_iterator_references<
+    typename raw_reference_tuple_helper<Ts>::type...
+  > type;
+};
+
+
+} // end raw_reference_detail
+
+
+// a couple of specializations of raw_reference for tuples follow
+
+
+// if a tuple "tuple_type" is_unwrappable,
+//   then the raw_reference of tuple_type is a tuple of its members' raw_references
+//   else the raw_reference of tuple_type is tuple_type &
+template <
+  typename... Ts
+>
+  struct raw_reference<
+    thrust::tuple<Ts...>
+  >
+{
+  private:
+    typedef thrust::tuple<Ts...> tuple_type;
+
+  public:
+    typedef typename eval_if<
+      is_unwrappable<tuple_type>::value,
+      raw_reference_detail::raw_reference_tuple_helper<tuple_type>,
+      add_reference<tuple_type>
+    >::type type;
+};
+
+
+template <
+  typename... Ts
+>
+  struct raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+{
+  private:
+    typedef detail::tuple_of_iterator_references<Ts...> tuple_type;
+
+  public:
+    typedef typename raw_reference_detail::raw_reference_tuple_helper<tuple_type>::type type;
+
+    // XXX figure out why is_unwrappable seems to be broken for tuple_of_iterator_references
+    //typedef typename eval_if<
+    //  is_unwrappable<tuple_type>::value,
+    //  raw_reference_detail::raw_reference_tuple_helper<tuple_type>,
+    //  add_reference<tuple_type>
+    //>::type type;
+};
+
+
+} // end detail
+
+
+// provide declarations of raw_reference_cast's overloads for raw_reference_caster below
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<T>::type
+  raw_reference_cast(T &ref);
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<const T>::type
+  raw_reference_cast(const T &ref);
+
+
+template<
+  typename... Ts
+>
+__host__ __device__
+typename detail::enable_if_unwrappable<
+  thrust::detail::tuple_of_iterator_references<Ts...>,
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+>::type
+raw_reference_cast(thrust::detail::tuple_of_iterator_references<Ts...> t);
+
+
+namespace detail
+{
+
+
+struct raw_reference_caster
+{
+  template<typename T>
+  __host__ __device__
+  typename detail::raw_reference<T>::type operator()(T &ref)
+  {
+    return thrust::raw_reference_cast(ref);
+  }
+
+  template<typename T>
+  __host__ __device__
+  typename detail::raw_reference<const T>::type operator()(const T &ref)
+  {
+    return thrust::raw_reference_cast(ref);
+  }
+
+  template<
+    typename... Ts
+  >
+  __host__ __device__
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+  operator()(thrust::detail::tuple_of_iterator_references<Ts...> t,
+             typename enable_if<
+               is_unwrappable<thrust::detail::tuple_of_iterator_references<Ts...> >::value
+             >::type * = 0)
+  {
+    return thrust::raw_reference_cast(t);
+  }
+}; // end raw_reference_caster
+
+
+} // end detail
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<T>::type
+  raw_reference_cast(T &ref)
+{
+  return *thrust::raw_pointer_cast(&ref);
+} // end raw_reference_cast
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<const T>::type
+  raw_reference_cast(const T &ref)
+{
+  return *thrust::raw_pointer_cast(&ref);
+} // end raw_reference_cast
+
+
+template<
+  typename... Ts
+>
+__host__ __device__
+typename detail::enable_if_unwrappable<
+  thrust::detail::tuple_of_iterator_references<Ts...>,
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+>::type
+raw_reference_cast(thrust::detail::tuple_of_iterator_references<Ts...> t)
+{
+  thrust::detail::raw_reference_caster f;
+
+  // note that we pass raw_reference_tuple_helper, not raw_reference as the unary metafunction
+  // the different way that raw_reference_tuple_helper unwraps tuples is important
+  return thrust::detail::tuple_host_device_transform<detail::raw_reference_detail::raw_reference_tuple_helper>(t, f);
+} // end raw_reference_cast
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reduce.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reduce.inl
new file mode 100644
index 0000000000000000000000000000000000000000..448a4b38c4a6c2682b96153b71d399e7526d4e5b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reduce.inl
@@ -0,0 +1,276 @@
+/*
+ *  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>
+
+#include <thrust/reduce.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/reduce.h>
+#include <thrust/system/detail/generic/reduce_by_key.h>
+#include <thrust/system/detail/adl/reduce.h>
+#include <thrust/system/detail/adl/reduce_by_key.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator>
+__host__ __device__
+  typename thrust::iterator_traits<InputIterator>::value_type
+    reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last)
+{
+  using thrust::system::detail::generic::reduce;
+  return reduce(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end reduce()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+  T reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+           InputIterator first,
+           InputIterator last,
+           T init)
+{
+  using thrust::system::detail::generic::reduce;
+  return reduce(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init);
+} // end reduce()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename T,
+         typename BinaryFunction>
+__host__ __device__
+  T reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+           InputIterator first,
+           InputIterator last,
+           T init,
+           BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::reduce;
+  return reduce(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init, binary_op);
+} // end reduce()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(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::reduce_by_key;
+  return reduce_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output);
+} // end reduce_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(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::reduce_by_key;
+  return reduce_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end reduce_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(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,
+                BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::reduce_by_key;
+  return reduce_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred, binary_op);
+} // end reduce_by_key()
+
+
+template<typename InputIterator>
+typename thrust::iterator_traits<InputIterator>::value_type
+  reduce(InputIterator first,
+         InputIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::reduce(select_system(system), first, last);
+}
+
+
+template<typename InputIterator,
+         typename T>
+   T reduce(InputIterator first,
+            InputIterator last,
+            T init)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::reduce(select_system(system), first, last, init);
+}
+
+
+template<typename InputIterator,
+         typename T,
+         typename BinaryFunction>
+   T reduce(InputIterator first,
+            InputIterator last,
+            T init,
+            BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::reduce(select_system(system), first, last, init, binary_op);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first,
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::reduce_by_key(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first,
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output,
+                BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::reduce_by_key(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first,
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output,
+                BinaryPredicate binary_pred,
+                BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::reduce_by_key(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred, binary_op);
+}
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cc13625dafe81ab42ef23a3ab02902c564432b3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference.h
@@ -0,0 +1,518 @@
+/*
+ *  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>
+#include <thrust/detail/reference_forward_declaration.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/memory.h>
+#include <thrust/system/detail/adl/get_value.h>
+#include <thrust/system/detail/adl/assign_value.h>
+#include <thrust/system/detail/adl/iter_swap.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <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 = typename thrust::remove_cvref<Element>::type;
+
+  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>
+  __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.
+   */
+  __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>.
+   */
+  __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>
+  __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>.
+   */
+  __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.
+   */
+  __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);
+  }
+
+  __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.
+  __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);
+  }
+
+  __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();
+  }
+
+  __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();
+  }
+
+  __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 loooking 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;
+
+  __host__ __device__
+  derived_type& derived() { return static_cast<derived_type&>(*this); }
+
+  template<typename System>
+  __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>
+  __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>
+  __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>
+  __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>
+  __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>
+  __host__ __device__
+  void swap(System* system, derived_type& other)
+  {
+    using thrust::system::detail::generic::select_system;
+    using thrust::system::detail::generic::iter_swap;
+
+    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>
+  __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.
+   */
+  __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>.
+   */
+  __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>
+  __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>.
+   */
+  __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.
+ */
+template <typename Element, typename Tag>
+__host__ __device__
+void swap(tagged_reference<Element, Tag>& x, tagged_reference<Element, Tag>& y)
+{
+  x.swap(y);
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference_forward_declaration.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference_forward_declaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f2b999497abe289b43af6ef828f8151a927ec96
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reference_forward_declaration.h
@@ -0,0 +1,28 @@
+/*
+ *  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>
+#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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/remove.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/remove.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7ccc0cc4656a3f0274042d51f5b5064448fdb73a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/remove.inl
@@ -0,0 +1,246 @@
+/*
+ *  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>
+#include <thrust/remove.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/remove.h>
+#include <thrust/system/detail/adl/remove.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename T>
+__host__ __device__
+  ForwardIterator remove(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         ForwardIterator first,
+                         ForwardIterator last,
+                         const T &value)
+{
+  using thrust::system::detail::generic::remove;
+  return remove(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+} // end remove()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator remove_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             InputIterator first,
+                             InputIterator last,
+                             OutputIterator result,
+                             const T &value)
+{
+  using thrust::system::detail::generic::remove_copy;
+  return remove_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, value);
+} // end remove_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator remove_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::remove_if;
+  return remove_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end remove_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator remove_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred)
+{
+  using thrust::system::detail::generic::remove_copy_if;
+  return remove_copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred);
+} // end remove_copy_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator remove_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::remove_if;
+  return remove_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, pred);
+} // end remove_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator remove_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::remove_copy_if;
+  return remove_copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred);
+} // end remove_copy_if()
+
+
+template<typename ForwardIterator,
+         typename T>
+  ForwardIterator remove(ForwardIterator first,
+                         ForwardIterator last,
+                         const T &value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::remove(select_system(system), first, last, value);
+} // end remove()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T>
+  OutputIterator remove_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator result,
+                             const T &value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::remove_copy(select_system(system1,system2), first, last, result, value);
+} // end remove_copy()
+
+
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator remove_if(ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::remove_if(select_system(system), first, last, pred);
+} // end remove_if()
+
+
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator remove_if(ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+  typedef typename thrust::iterator_system<InputIterator>::type   System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::remove_if(select_system(system1,system2), first, last, stencil, pred);
+} // end remove_if()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::remove_copy_if(select_system(system1,system2), first, last, result, pred);
+} // end remove_copy_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(InputIterator1 first,
+                                InputIterator1 last,
+                                InputIterator2 stencil,
+                                OutputIterator result,
+                                Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::remove_copy_if(select_system(system1,system2,system3), first, last, stencil, result, pred);
+} // end remove_copy_if()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/replace.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/replace.inl
new file mode 100644
index 0000000000000000000000000000000000000000..629287bee0833304711320dbf3e1ec98d01f2bbd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/replace.inl
@@ -0,0 +1,218 @@
+/*
+ *  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>
+#include <thrust/replace.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/replace.h>
+#include <thrust/system/detail/adl/replace.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void replace(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+               ForwardIterator first, ForwardIterator last,
+               const T &old_value,
+               const T &new_value)
+{
+  using thrust::system::detail::generic::replace;
+  return replace(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, old_value, new_value);
+} // end replace()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Predicate, typename T>
+__host__ __device__
+  void replace_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  ForwardIterator first, ForwardIterator last,
+                  Predicate pred,
+                  const T &new_value)
+{
+  using thrust::system::detail::generic::replace_if;
+  return replace_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred, new_value);
+} // end replace_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename Predicate, typename T>
+__host__ __device__
+  void replace_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  ForwardIterator first, ForwardIterator last,
+                  InputIterator stencil,
+                  Predicate pred,
+                  const T &new_value)
+{
+  using thrust::system::detail::generic::replace_if;
+  return replace_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, pred, new_value);
+} // end replace_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename T>
+__host__ __device__
+  OutputIterator replace_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator first, InputIterator last,
+                              OutputIterator result,
+                              const T &old_value,
+                              const T &new_value)
+{
+  using thrust::system::detail::generic::replace_copy;
+  return replace_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, old_value, new_value);
+} // end replace_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate, typename T>
+__host__ __device__
+  OutputIterator replace_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                 InputIterator first, InputIterator last,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value)
+{
+  using thrust::system::detail::generic::replace_copy_if;
+  return replace_copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred, new_value);
+} // end replace_copy_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename T>
+__host__ __device__
+  OutputIterator replace_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                 InputIterator1 first, InputIterator1 last,
+                                 InputIterator2 stencil,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value)
+{
+  using thrust::system::detail::generic::replace_copy_if;
+  return replace_copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred, new_value);
+} // end replace_copy_if()
+
+
+template<typename InputIterator, typename OutputIterator, typename Predicate, typename T>
+  OutputIterator replace_copy_if(InputIterator first, InputIterator last,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::replace_copy_if(select_system(system1,system2), first, last, result, pred, new_value);
+} // end replace_copy_if()
+
+
+template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename T>
+  OutputIterator replace_copy_if(InputIterator1 first, InputIterator1 last,
+                                 InputIterator2 stencil,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::replace_copy_if(select_system(system1,system2,system3), first, last, stencil, result, pred, new_value);
+} // end replace_copy_if()
+
+
+template<typename InputIterator, typename OutputIterator, typename T>
+  OutputIterator replace_copy(InputIterator first, InputIterator last,
+                              OutputIterator result,
+                              const T &old_value,
+                              const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::replace_copy(select_system(system1,system2), first, last, result, old_value, new_value);
+} // end replace_copy()
+
+
+template<typename ForwardIterator, typename Predicate, typename T>
+  void replace_if(ForwardIterator first, ForwardIterator last,
+                  Predicate pred,
+                  const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::replace_if(select_system(system), first, last, pred, new_value);
+} // end replace_if()
+
+
+template<typename ForwardIterator, typename InputIterator, typename Predicate, typename T>
+  void replace_if(ForwardIterator first, ForwardIterator last,
+                  InputIterator stencil,
+                  Predicate pred,
+                  const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+  typedef typename thrust::iterator_system<InputIterator>::type   System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::replace_if(select_system(system1,system2), first, last, stencil, pred, new_value);
+} // end replace_if()
+
+
+template<typename ForwardIterator, typename T>
+  void replace(ForwardIterator first, ForwardIterator last,
+               const T &old_value,
+               const T &new_value)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::replace(select_system(system), first, last, old_value, new_value);
+} // end replace()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reverse.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reverse.inl
new file mode 100644
index 0000000000000000000000000000000000000000..dc316d18f52f75d0d9bc5c0a70c37be0fce5b113
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/reverse.inl
@@ -0,0 +1,87 @@
+/*
+ *  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>
+#include <thrust/reverse.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/reverse.h>
+#include <thrust/system/detail/adl/reverse.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename BidirectionalIterator>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename BidirectionalIterator, typename OutputIterator>
+__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;
+
+  typedef typename thrust::iterator_system<BidirectionalIterator>::type System;
+
+  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;
+
+  typedef typename thrust::iterator_system<BidirectionalIterator>::type System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type        System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::reverse_copy(select_system(system1,system2), first, last, result);
+} // end reverse_copy()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scan.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scan.inl
new file mode 100644
index 0000000000000000000000000000000000000000..b781b0e280c160366cf028b10cf9001cc35378e0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scan.inl
@@ -0,0 +1,522 @@
+/*
+ *  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>
+#include <thrust/scan.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/scan.h>
+#include <thrust/system/detail/generic/scan_by_key.h>
+#include <thrust/system/detail/adl/scan.h>
+#include <thrust/system/detail/adl/scan_by_key.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  using thrust::system::detail::generic::inclusive_scan;
+  return inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end inclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::inclusive_scan;
+  return inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, binary_op);
+} // end inclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  using thrust::system::detail::generic::exclusive_scan;
+  return exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end exclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init)
+{
+  using thrust::system::detail::generic::exclusive_scan;
+  return exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, init);
+} // end exclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init,
+                                AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::exclusive_scan;
+  return exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, init, binary_op);
+} // end exclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result)
+{
+  using thrust::system::detail::generic::inclusive_scan_by_key;
+  return inclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result);
+} // end inclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::inclusive_scan_by_key;
+  return inclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, binary_pred);
+} // end inclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::inclusive_scan_by_key;
+  return inclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, binary_pred, binary_op);
+} // end inclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result)
+{
+  using thrust::system::detail::generic::exclusive_scan_by_key;
+  return exclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result);
+} // end exclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init)
+{
+  using thrust::system::detail::generic::exclusive_scan_by_key;
+  return exclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, init);
+} // end exclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::exclusive_scan_by_key;
+  return exclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, init, binary_pred);
+} // end exclusive_scan_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::exclusive_scan_by_key;
+  return exclusive_scan_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, init, binary_pred, binary_op);
+} // end exclusive_scan_by_key()
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator inclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::inclusive_scan(select_system(system1,system2), first, last, result);
+} // end inclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction>
+  OutputIterator inclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::inclusive_scan(select_system(system1,system2), first, last, result, binary_op);
+} // end inclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::exclusive_scan(select_system(system1,system2), first, last, result);
+} // end exclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::exclusive_scan(select_system(system1,system2), first, last, result, init);
+} // end exclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename BinaryFunction>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init,
+                                BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::exclusive_scan(select_system(system1,system2), first, last, result, init, binary_op);
+} // end exclusive_scan()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::inclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::inclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result, binary_pred);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::inclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result, binary_pred, binary_op);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::exclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::exclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result, init);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::exclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result, init, binary_pred);
+}
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::exclusive_scan_by_key(select_system(system1,system2,system3), first1, last1, first2, result, init, binary_pred, binary_op);
+}
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scatter.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scatter.inl
new file mode 100644
index 0000000000000000000000000000000000000000..30dd611d11f0ba97e39bbc62d4f633a0a2545897
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/scatter.inl
@@ -0,0 +1,163 @@
+/*
+ *  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>
+
+#include <thrust/scatter.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/scatter.h>
+#include <thrust/system/detail/adl/scatter.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator>
+__host__ __device__
+  void scatter(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+               InputIterator1 first,
+               InputIterator1 last,
+               InputIterator2 map,
+               RandomAccessIterator output)
+{
+  using thrust::system::detail::generic::scatter;
+  return scatter(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, map, output);
+} // end scatter()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator>
+__host__ __device__
+  void scatter_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output)
+{
+  using thrust::system::detail::generic::scatter_if;
+  return scatter_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, map, stencil, output);
+} // end scatter_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator,
+         typename Predicate>
+__host__ __device__
+  void scatter_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output,
+                  Predicate pred)
+{
+  using thrust::system::detail::generic::scatter_if;
+  return scatter_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, map, stencil, output, pred);
+} // end scatter_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator>
+  void scatter(InputIterator1 first,
+               InputIterator1 last,
+               InputIterator2 map,
+               RandomAccessIterator output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::scatter(select_system(system1,system2,system3), first, last, map, output);
+} // end scatter()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator>
+  void scatter_if(InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type       System3;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::scatter_if(select_system(system1,system2,system3,system4), first, last, map, stencil, output);
+} // end scatter_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator,
+         typename Predicate>
+  void scatter_if(InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output,
+                  Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type       System3;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::scatter_if(select_system(system1,system2,system3,system4), first, last, map, stencil, output, pred);
+} // end scatter_if()
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/select_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/select_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..968446162dd2f8f752865f2e6566da1b9fc89634
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/select_system.h
@@ -0,0 +1,84 @@
+/*
+ *  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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// We need a way to compute the return type of `select_system`, which is found
+// by using `thrust::system::detail::generic::select_system` and then making an
+// ADL call. We have no trait that defines the return type. With the
+// limitations of C++11 return type deduction, we need to be able to stick all
+// of that into `decltype`. So, we put the using statement into a detail
+// namespace, and then implement the generic dispatch function in that
+// namespace.
+
+namespace select_system_detail
+{
+
+using thrust::system::detail::generic::select_system;
+
+struct select_system_fn final
+{
+  __thrust_exec_check_disable__
+  template <typename DerivedPolicy0>
+  __host__ __device__
+  auto operator()(
+    thrust::detail::execution_policy_base<DerivedPolicy0> const& exec0
+  ) const
+  THRUST_DECLTYPE_RETURNS(
+    select_system(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec0))
+    )
+  )
+
+  __thrust_exec_check_disable__
+  template <typename DerivedPolicy0, typename DerivedPolicy1>
+  __host__ __device__
+  auto operator()(
+    thrust::detail::execution_policy_base<DerivedPolicy0> const& exec0
+  , thrust::detail::execution_policy_base<DerivedPolicy1> const& exec1
+  ) const
+  THRUST_DECLTYPE_RETURNS(
+    select_system(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec0))
+    , thrust::detail::derived_cast(thrust::detail::strip_const(exec1))
+    )
+  )
+};
+
+} // namespace select_system_detail
+
+THRUST_INLINE_CONSTANT select_system_detail::select_system_fn select_system{};
+
+} // detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/seq.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/seq.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba18c2dbf515c96b7dff372982e032ddb81dd313
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/seq.h
@@ -0,0 +1,52 @@
+/*
+ *  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>
+#include <thrust/detail/allocator_aware_execution_policy.h>
+#include <thrust/system/detail/sequential/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+struct seq_t : thrust::system::detail::sequential::execution_policy<seq_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    thrust::system::detail::sequential::execution_policy>
+{
+  __host__ __device__
+  constexpr seq_t() : thrust::system::detail::sequential::execution_policy<seq_t>() {}
+
+  // allow any execution_policy to convert to seq_t
+  template<typename DerivedPolicy>
+  __host__ __device__
+  seq_t(const thrust::execution_policy<DerivedPolicy> &)
+    : thrust::system::detail::sequential::execution_policy<seq_t>()
+  {}
+};
+
+
+} // end detail
+
+
+THRUST_INLINE_CONSTANT detail::seq_t seq;
+
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sequence.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sequence.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ffc9b968b97d3747a0b3ef16996c125505acdde0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sequence.inl
@@ -0,0 +1,114 @@
+/*
+ *  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>
+#include <thrust/sequence.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/sequence.h>
+#include <thrust/system/detail/adl/sequence.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last)
+{
+  using thrust::system::detail::generic::sequence;
+  return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end sequence()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                T init)
+{
+  using thrust::system::detail::generic::sequence;
+  return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init);
+} // end sequence()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                T init,
+                T step)
+{
+  using thrust::system::detail::generic::sequence;
+  return sequence(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, init, step);
+} // end sequence()
+
+
+template<typename ForwardIterator>
+  void sequence(ForwardIterator first,
+                ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::sequence(select_system(system), first, last);
+} // end sequence()
+
+
+template<typename ForwardIterator, typename T>
+  void sequence(ForwardIterator first,
+                ForwardIterator last,
+                T init)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::sequence(select_system(system), first, last, init);
+} // end sequence()
+
+
+template<typename ForwardIterator, typename T>
+  void sequence(ForwardIterator first,
+                ForwardIterator last,
+                T init,
+                T step)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::sequence(select_system(system), first, last, init, step);
+} // end sequence()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/set_operations.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/set_operations.inl
new file mode 100644
index 0000000000000000000000000000000000000000..7915f7b3eab6c76c39d5208a181c08a53646596c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/set_operations.inl
@@ -0,0 +1,865 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/set_operations.h>
+#include <thrust/system/detail/adl/set_operations.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator set_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator1                                              first1,
+                              InputIterator1                                              last1,
+                              InputIterator2                                              first2,
+                              InputIterator2                                              last2,
+                              OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::set_difference;
+  return set_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end set_difference()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+OutputIterator set_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator1                                              first1,
+                              InputIterator1                                              last1,
+                              InputIterator2                                              first2,
+                              InputIterator2                                              last2,
+                              OutputIterator                                              result,
+                              StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_difference;
+  return set_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end set_difference()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator1                                              keys_first1,
+                        InputIterator1                                              keys_last1,
+                        InputIterator2                                              keys_first2,
+                        InputIterator2                                              keys_last2,
+                        InputIterator3                                              values_first1,
+                        InputIterator4                                              values_first2,
+                        OutputIterator1                                             keys_result,
+                        OutputIterator2                                             values_result)
+{
+  using thrust::system::detail::generic::set_difference_by_key;
+  return set_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_difference_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator1                                              keys_first1,
+                        InputIterator1                                              keys_last1,
+                        InputIterator2                                              keys_first2,
+                        InputIterator2                                              keys_last2,
+                        InputIterator3                                              values_first1,
+                        InputIterator4                                              values_first2,
+                        OutputIterator1                                             keys_result,
+                        OutputIterator2                                             values_result,
+                        StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_difference_by_key;
+  return set_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_difference_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator set_intersection(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator1                                              first1,
+                                InputIterator1                                              last1,
+                                InputIterator2                                              first2,
+                                InputIterator2                                              last2,
+                                OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::set_intersection;
+  return set_intersection(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end set_intersection()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+OutputIterator set_intersection(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator1                                              first1,
+                                InputIterator1                                              last1,
+                                InputIterator2                                              first2,
+                                InputIterator2                                              last2,
+                                OutputIterator                                              result,
+                                StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_intersection;
+  return set_intersection(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end set_intersection()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_intersection_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1                                              keys_first1,
+                          InputIterator1                                              keys_last1,
+                          InputIterator2                                              keys_first2,
+                          InputIterator2                                              keys_last2,
+                          InputIterator3                                              values_first1,
+                          OutputIterator1                                             keys_result,
+                          OutputIterator2                                             values_result)
+{
+  using thrust::system::detail::generic::set_intersection_by_key;
+  return set_intersection_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result);
+} // end set_intersection_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_intersection_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1                                              keys_first1,
+                          InputIterator1                                              keys_last1,
+                          InputIterator2                                              keys_first2,
+                          InputIterator2                                              keys_last2,
+                          InputIterator3                                              values_first1,
+                          OutputIterator1                                             keys_result,
+                          OutputIterator2                                             values_result,
+                          StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_intersection_by_key;
+  return set_intersection_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result, comp);
+} // end set_intersection_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                        InputIterator1                                              first1,
+                                        InputIterator1                                              last1,
+                                        InputIterator2                                              first2,
+                                        InputIterator2                                              last2,
+                                        OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::set_symmetric_difference;
+  return set_symmetric_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end set_symmetric_difference()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                        InputIterator1                                              first1,
+                                        InputIterator1                                              last1,
+                                        InputIterator2                                              first2,
+                                        InputIterator2                                              last2,
+                                        OutputIterator                                              result,
+                                        StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_symmetric_difference;
+  return set_symmetric_difference(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end set_symmetric_difference()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_symmetric_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  InputIterator1                                              keys_first1,
+                                  InputIterator1                                              keys_last1,
+                                  InputIterator2                                              keys_first2,
+                                  InputIterator2                                              keys_last2,
+                                  InputIterator3                                              values_first1,
+                                  InputIterator4                                              values_first2,
+                                  OutputIterator1                                             keys_result,
+                                  OutputIterator2                                             values_result)
+{
+  using thrust::system::detail::generic::set_symmetric_difference_by_key;
+  return set_symmetric_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_symmetric_difference_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_symmetric_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  InputIterator1                                              keys_first1,
+                                  InputIterator1                                              keys_last1,
+                                  InputIterator2                                              keys_first2,
+                                  InputIterator2                                              keys_last2,
+                                  InputIterator3                                              values_first1,
+                                  InputIterator4                                              values_first2,
+                                  OutputIterator1                                             keys_result,
+                                  OutputIterator2                                             values_result,
+                                  StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_symmetric_difference_by_key;
+  return set_symmetric_difference_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_symmetric_difference_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator set_union(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1                                              first1,
+                         InputIterator1                                              last1,
+                         InputIterator2                                              first2,
+                         InputIterator2                                              last2,
+                         OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::set_union;
+  return set_union(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end set_union()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+OutputIterator set_union(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1                                              first1,
+                         InputIterator1                                              last1,
+                         InputIterator2                                              first2,
+                         InputIterator2                                              last2,
+                         OutputIterator                                              result,
+                         StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_union;
+  return set_union(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end set_union()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_union_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator1                                              keys_first1,
+                   InputIterator1                                              keys_last1,
+                   InputIterator2                                              keys_first2,
+                   InputIterator2                                              keys_last2,
+                   InputIterator3                                              values_first1,
+                   InputIterator4                                              values_first2,
+                   OutputIterator1                                             keys_result,
+                   OutputIterator2                                             values_result)
+{
+  using thrust::system::detail::generic::set_union_by_key;
+  return set_union_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_union_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+thrust::pair<OutputIterator1,OutputIterator2>
+  set_union_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator1                                              keys_first1,
+                   InputIterator1                                              keys_last1,
+                   InputIterator2                                              keys_first2,
+                   InputIterator2                                              keys_last2,
+                   InputIterator3                                              values_first1,
+                   InputIterator4                                              values_first2,
+                   OutputIterator1                                             keys_result,
+                   OutputIterator2                                             values_result,
+                   StrictWeakCompare                                           comp)
+{
+  using thrust::system::detail::generic::set_union_by_key;
+  return set_union_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_union_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator set_difference(InputIterator1 first1,
+                                InputIterator1 last1,
+                                InputIterator2 first2,
+                                InputIterator2 last2,
+                                OutputIterator result,
+                                StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end set_difference()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_difference(InputIterator1 first1,
+                                InputIterator1 last1,
+                                InputIterator2 first2,
+                                InputIterator2 last2,
+                                OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end set_difference()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(InputIterator1 keys_first1,
+                          InputIterator1 keys_last1,
+                          InputIterator2 keys_first2,
+                          InputIterator2 keys_last2,
+                          InputIterator3 values_first1,
+                          InputIterator4 values_first2,
+                          OutputIterator1 keys_result,
+                          OutputIterator2 values_result,
+                          StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_difference_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(InputIterator1 keys_first1,
+                          InputIterator1 keys_last1,
+                          InputIterator2 keys_first2,
+                          InputIterator2 keys_last2,
+                          InputIterator3 values_first1,
+                          InputIterator4 values_first2,
+                          OutputIterator1 keys_result,
+                          OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_difference_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator set_intersection(InputIterator1 first1,
+                                  InputIterator1 last1,
+                                  InputIterator2 first2,
+                                  InputIterator2 last2,
+                                  OutputIterator result,
+                                  StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_intersection(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end set_intersection()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_intersection(InputIterator1 first1,
+                                  InputIterator1 last1,
+                                  InputIterator2 first2,
+                                  InputIterator2 last2,
+                                  OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_intersection(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end set_intersection()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(InputIterator1 keys_first1,
+                            InputIterator1 keys_last1,
+                            InputIterator2 keys_first2,
+                            InputIterator2 keys_last2,
+                            InputIterator3 values_first1,
+                            OutputIterator1 keys_result,
+                            OutputIterator2 values_result,
+                            StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System4;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System5;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+
+  return thrust::set_intersection_by_key(select_system(system1,system2,system3,system4,system5), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result, comp);
+} // end set_intersection_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(InputIterator1 keys_first1,
+                            InputIterator1 keys_last1,
+                            InputIterator2 keys_first2,
+                            InputIterator2 keys_last2,
+                            InputIterator3 values_first1,
+                            OutputIterator1 keys_result,
+                            OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System4;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System5;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+
+  return thrust::set_intersection_by_key(select_system(system1,system2,system3,system4,system5), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, keys_result, values_result);
+} // end set_intersection_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator set_symmetric_difference(InputIterator1 first1,
+                                          InputIterator1 last1,
+                                          InputIterator2 first2,
+                                          InputIterator2 last2,
+                                          OutputIterator result,
+                                          StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_symmetric_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end set_symmetric_difference()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_symmetric_difference(InputIterator1 first1,
+                                          InputIterator1 last1,
+                                          InputIterator2 first2,
+                                          InputIterator2 last2,
+                                          OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_symmetric_difference(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end set_symmetric_difference()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(InputIterator1 keys_first1,
+                                    InputIterator1 keys_last1,
+                                    InputIterator2 keys_first2,
+                                    InputIterator2 keys_last2,
+                                    InputIterator3 values_first1,
+                                    InputIterator4 values_first2,
+                                    OutputIterator1 keys_result,
+                                    OutputIterator2 values_result,
+                                    StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_symmetric_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_symmetric_difference_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(InputIterator1 keys_first1,
+                                    InputIterator1 keys_last1,
+                                    InputIterator2 keys_first2,
+                                    InputIterator2 keys_last2,
+                                    InputIterator3 values_first1,
+                                    InputIterator4 values_first2,
+                                    OutputIterator1 keys_result,
+                                    OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_symmetric_difference_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_symmetric_difference_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator set_union(InputIterator1 first1,
+                           InputIterator1 last1,
+                           InputIterator2 first2,
+                           InputIterator2 last2,
+                           OutputIterator result,
+                           StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_union(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end set_union()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_union(InputIterator1 first1,
+                           InputIterator1 last1,
+                           InputIterator2 first2,
+                           InputIterator2 last2,
+                           OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::set_union(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end set_union()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(InputIterator1 keys_first1,
+                     InputIterator1 keys_last1,
+                     InputIterator2 keys_first2,
+                     InputIterator2 keys_last2,
+                     InputIterator3 values_first1,
+                     InputIterator4 values_first2,
+                     OutputIterator1 keys_result,
+                     OutputIterator2 values_result,
+                     StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_union_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end set_union_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(InputIterator1 keys_first1,
+                     InputIterator1 keys_last1,
+                     InputIterator2 keys_first2,
+                     InputIterator2 keys_last2,
+                     InputIterator3 values_first1,
+                     InputIterator4 values_first2,
+                     OutputIterator1 keys_result,
+                     OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::set_union_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end set_union_by_key()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/shuffle.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/shuffle.inl
new file mode 100644
index 0000000000000000000000000000000000000000..48f5ba639294f74087247af75e1aa3b58e728804
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/shuffle.inl
@@ -0,0 +1,83 @@
+/*
+ *  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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/shuffle.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/shuffle.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename RandomIterator, typename URBG>
+__host__ __device__ void shuffle(
+    const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+    RandomIterator first, RandomIterator last, URBG&& g) {
+  using thrust::system::detail::generic::shuffle;
+  return shuffle(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      first, last, g);
+}
+
+template <typename RandomIterator, typename URBG>
+__host__ __device__ void shuffle(RandomIterator first, RandomIterator last,
+                                 URBG&& g) {
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomIterator>::type System;
+  System system;
+
+  return thrust::shuffle(select_system(system), first, last, g);
+}
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename RandomIterator,
+          typename OutputIterator, typename URBG>
+__host__ __device__ void shuffle_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+    RandomIterator first, RandomIterator last, OutputIterator result,
+    URBG&& g) {
+  using thrust::system::detail::generic::shuffle_copy;
+  return shuffle_copy(
+      thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+      first, last, result, g);
+}
+
+template <typename RandomIterator, typename OutputIterator, typename URBG>
+__host__ __device__ void shuffle_copy(RandomIterator first, RandomIterator last,
+                                      OutputIterator result, URBG&& g) {
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomIterator>::type System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::shuffle_copy(select_system(system1, system2), first, last,
+                              result, g);
+}
+
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sort.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sort.inl
new file mode 100644
index 0000000000000000000000000000000000000000..53f8bad93b1d000e84d1f40ed1fefbf12886a591
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/sort.inl
@@ -0,0 +1,404 @@
+/*
+ *  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>
+#include <thrust/sort.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/sort.h>
+#include <thrust/system/detail/adl/sort.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename RandomAccessIterator>
+__host__ __device__
+  void sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            RandomAccessIterator first,
+            RandomAccessIterator last)
+{
+  using thrust::system::detail::generic::sort;
+  return sort(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end sort()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            RandomAccessIterator first,
+            RandomAccessIterator last,
+            StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::sort;
+  return sort(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end sort()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename RandomAccessIterator>
+__host__ __device__
+  void stable_sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator last)
+{
+  using thrust::system::detail::generic::stable_sort;
+  return stable_sort(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end stable_sort()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void stable_sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::stable_sort;
+  return stable_sort(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end stable_sort()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+__host__ __device__
+  void sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first)
+{
+  using thrust::system::detail::generic::sort_by_key;
+  return sort_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first);
+} // end sort_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first,
+                   StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::sort_by_key;
+  return sort_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, comp);
+} // end sort_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+__host__ __device__
+  void stable_sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first)
+{
+  using thrust::system::detail::generic::stable_sort_by_key;
+  return stable_sort_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first);
+} // end stable_sort_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void stable_sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first,
+                          StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::stable_sort_by_key;
+  return stable_sort_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, comp);
+} // end stable_sort_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  bool is_sorted(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::is_sorted;
+  return is_sorted(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end is_sorted()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Compare>
+__host__ __device__
+  bool is_sorted(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 Compare comp)
+{
+  using thrust::system::detail::generic::is_sorted;
+  return is_sorted(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end is_sorted()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator is_sorted_until(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last)
+{
+  using thrust::system::detail::generic::is_sorted_until;
+  return is_sorted_until(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end is_sorted_until()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Compare>
+__host__ __device__
+  ForwardIterator is_sorted_until(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last,
+                                  Compare comp)
+{
+  using thrust::system::detail::generic::is_sorted_until;
+  return is_sorted_until(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end is_sorted_until()
+
+
+///////////////
+// Key Sorts //
+///////////////
+
+template<typename RandomAccessIterator>
+  void sort(RandomAccessIterator first,
+            RandomAccessIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System;
+
+  System system;
+
+  return thrust::sort(select_system(system), first, last);
+} // end sort()
+
+
+template<typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+  __host__ __device__
+  void sort(RandomAccessIterator first,
+            RandomAccessIterator last,
+            StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System;
+
+  System system;
+
+  return thrust::sort(select_system(system), first, last, comp);
+} // end sort()
+
+
+template<typename RandomAccessIterator>
+  void stable_sort(RandomAccessIterator first,
+                   RandomAccessIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System;
+
+  System system;
+
+  return thrust::stable_sort(select_system(system), first, last);
+} // end stable_sort()
+
+
+template<typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+  void stable_sort(RandomAccessIterator first,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System;
+
+  System system;
+
+  return thrust::stable_sort(select_system(system), first, last, comp);
+} // end stable_sort()
+
+
+
+/////////////////////
+// Key-Value Sorts //
+/////////////////////
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  void sort_by_key(RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator1>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::sort_by_key(select_system(system1,system2), keys_first, keys_last, values_first);
+} // end sort_by_key()
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void sort_by_key(RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first,
+                   StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator1>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::sort_by_key(select_system(system1,system2), keys_first, keys_last, values_first, comp);
+} // end sort_by_key()
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  void stable_sort_by_key(RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator1>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::stable_sort_by_key(select_system(system1,system2), keys_first, keys_last, values_first);
+} // end stable_sort_by_key()
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void stable_sort_by_key(RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first,
+                          StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator1>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::stable_sort_by_key(select_system(system1,system2), keys_first, keys_last, values_first, comp);
+} // end stable_sort_by_key()
+
+
+template<typename ForwardIterator>
+  bool is_sorted(ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::is_sorted(select_system(system), first, last);
+} // end is_sorted()
+
+
+template<typename ForwardIterator,
+         typename Compare>
+  bool is_sorted(ForwardIterator first,
+                 ForwardIterator last,
+                 Compare comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::is_sorted(select_system(system), first, last, comp);
+} // end is_sorted()
+
+
+template<typename ForwardIterator>
+  ForwardIterator is_sorted_until(ForwardIterator first,
+                                  ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::is_sorted_until(select_system(system), first, last);
+} // end is_sorted_until()
+
+
+template<typename ForwardIterator,
+         typename Compare>
+  ForwardIterator is_sorted_until(ForwardIterator first,
+                                  ForwardIterator last,
+                                  Compare comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::is_sorted_until(select_system(system), first, last, comp);
+} // end is_sorted_until()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_assert.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_assert.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e613279055525f39891e6286d46272de070a430
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_assert.h
@@ -0,0 +1,91 @@
+/*
+ *  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.
+ */
+
+/*
+ * (C) Copyright John Maddock 2000.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/preprocessor.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename, bool x>
+struct depend_on_instantiation
+{
+  THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT bool value = x;
+};
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#  if THRUST_CPP_DIALECT >= 2017
+#    define THRUST_STATIC_ASSERT(B)        static_assert(B)
+#  else
+#    define THRUST_STATIC_ASSERT(B)        static_assert(B, "static assertion failed")
+#  endif
+#  define THRUST_STATIC_ASSERT_MSG(B, msg) static_assert(B, msg)
+
+#else // Older than C++11.
+
+// HP aCC cannot deal with missing names for template value parameters.
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+
+template <> struct STATIC_ASSERTION_FAILURE<true> {};
+
+// HP aCC cannot deal with missing names for template value parameters.
+template <int x> struct static_assert_test {};
+
+#if    (  (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                  \
+       && (THRUST_GCC_VERSION >= 40800))                                      \
+    || (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG)
+  // Clang and GCC 4.8+ will complain about this typedef being unused unless we
+  // annotate it as such.
+#  define THRUST_STATIC_ASSERT(B)                                             \
+    typedef THRUST_NS_QUALIFIER::detail::static_assert_test<                  \
+      sizeof(THRUST_NS_QUALIFIER::detail::STATIC_ASSERTION_FAILURE<(bool)(B)>)\
+    >                                                                         \
+      THRUST_PP_CAT2(thrust_static_assert_typedef_, __LINE__)                 \
+      __attribute__((unused))                                                 \
+    /**/      
+#else
+#  define THRUST_STATIC_ASSERT(B)                                             \
+    typedef THRUST_NS_QUALIFIER::detail::static_assert_test<                  \
+      sizeof(THRUST_NS_QUALIFIER::detail::STATIC_ASSERTION_FAILURE<(bool)(B)>)\
+    >                                                                         \
+      THRUST_PP_CAT2(thrust_static_assert_typedef_, __LINE__)                 \
+    /**/      
+#endif
+
+#define THRUST_STATIC_ASSERT_MSG(B, msg) THRUST_STATIC_ASSERT(B)
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_map.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f0d79e83e2520c29986708beeb07fa776d5e1a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/static_map.h
@@ -0,0 +1,169 @@
+/*
+ *  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>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace static_map_detail
+{
+
+
+template<unsigned int k, unsigned int v>
+struct key_value
+{
+  static const unsigned int key = k;
+  static const unsigned int value = v;
+};
+
+
+template<typename Head, typename Tail = void>
+struct cons
+{
+  template<unsigned int key, unsigned int default_value>
+  struct static_get
+  {
+    static const unsigned int value = (key == Head::key) ? (Head::value) : Tail::template static_get<key,default_value>::value;
+  };
+
+
+  template<unsigned int default_value>
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return (key == Head::key) ? (Head::value) : Tail::template get<default_value>(key);
+  }
+};
+
+
+template<typename Head>
+struct cons<Head,void>
+{
+  template<unsigned int key, unsigned int default_value>
+  struct static_get
+  {
+    static const unsigned int value = (key == Head::key) ? (Head::value) : default_value;
+  };
+
+  template<unsigned int default_value>
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return (key == Head::key) ? (Head::value) : default_value;
+  }
+};
+
+
+template<unsigned int default_value,
+         unsigned int key0 = 0, unsigned int value0 = default_value,
+         unsigned int key1 = 0, unsigned int value1 = default_value,
+         unsigned int key2 = 0, unsigned int value2 = default_value,
+         unsigned int key3 = 0, unsigned int value3 = default_value,
+         unsigned int key4 = 0, unsigned int value4 = default_value,
+         unsigned int key5 = 0, unsigned int value5 = default_value,
+         unsigned int key6 = 0, unsigned int value6 = default_value,
+         unsigned int key7 = 0, unsigned int value7 = default_value>
+struct static_map
+{
+  typedef cons<
+    key_value<key0,value0>,
+    cons<
+      key_value<key1,value1>,
+      cons<
+        key_value<key2,value2>,
+        cons<
+          key_value<key3,value3>,
+          cons<
+            key_value<key4,value4>,
+            cons<
+              key_value<key5,value5>,
+              cons<
+                key_value<key6,value6>,
+                cons<
+                  key_value<key7,value7>
+                >
+              >
+            >
+          >
+        >
+      >
+    >
+  > impl;
+
+  template<unsigned int key>
+  struct static_get
+  {
+    static const unsigned int value = impl::template static_get<key,default_value>::value;
+  };
+
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return impl::template get<default_value>(key);
+  }
+};
+
+
+} // end namespace static_map_detail
+
+
+template<unsigned int default_value,
+         unsigned int key0 = 0, unsigned int value0 = default_value,
+         unsigned int key1 = 0, unsigned int value1 = default_value,
+         unsigned int key2 = 0, unsigned int value2 = default_value,
+         unsigned int key3 = 0, unsigned int value3 = default_value,
+         unsigned int key4 = 0, unsigned int value4 = default_value,
+         unsigned int key5 = 0, unsigned int value5 = default_value,
+         unsigned int key6 = 0, unsigned int value6 = default_value,
+         unsigned int key7 = 0, unsigned int value7 = default_value>
+struct static_map
+  : static_map_detail::static_map<
+      default_value,
+      key0, value0,
+      key1, value1,
+      key2, value2,
+      key3, value3,
+      key4, value4,
+      key5, value5,
+      key6, value6,
+      key7, value7
+    >
+{};
+
+
+template<unsigned int key, typename StaticMap>
+struct static_lookup
+{
+  static const unsigned int value = StaticMap::template static_get<key>::value;
+};
+
+
+template<typename StaticMap>
+__host__ __device__
+unsigned int lookup(unsigned int key)
+{
+  return StaticMap::get(key);
+}
+
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..305750f8ae7887058e4612f590313cb7c0fa962c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.h
@@ -0,0 +1,35 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename Assignable1, typename Assignable2>
+__host__ __device__
+inline void swap(Assignable1 &a, Assignable2 &b)
+{
+  Assignable1 temp = a;
+  a = b;
+  b = temp;
+} // end swap()
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.inl
new file mode 100644
index 0000000000000000000000000000000000000000..196c34f41ee48a4870c409c4957dbdbc6a7b375e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap.inl
@@ -0,0 +1,22 @@
+/*
+ *  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/swap.h>
+#include <thrust/detail/swap.h>
+#include <thrust/detail/swap_ranges.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap_ranges.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap_ranges.inl
new file mode 100644
index 0000000000000000000000000000000000000000..1f35c1ff3183df5b4ffe9692903896582d8139a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/swap_ranges.inl
@@ -0,0 +1,64 @@
+/*
+ *  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>
+
+#include <thrust/swap.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/swap_ranges.h>
+#include <thrust/system/detail/adl/swap_ranges.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__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;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::swap_ranges(select_system(system1,system2), first1, last1, first2);
+} // end swap_ranges()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tabulate.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tabulate.inl
new file mode 100644
index 0000000000000000000000000000000000000000..308be061faf2a0e8c7229a0cb9ae9d8847c39985
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tabulate.inl
@@ -0,0 +1,58 @@
+/*
+ *  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>
+#include <thrust/tabulate.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/tabulate.h>
+#include <thrust/system/detail/adl/tabulate.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename UnaryOperation>
+__host__ __device__
+  void tabulate(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                UnaryOperation unary_op)
+{
+  using thrust::system::detail::generic::tabulate;
+  return tabulate(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, unary_op);
+} // end tabulate()
+
+
+template<typename ForwardIterator, typename UnaryOperation>
+  void tabulate(ForwardIterator first,
+                ForwardIterator last,
+                UnaryOperation unary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::tabulate(select_system(system), first, last, unary_op);
+} // end tabulate()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf4bc7d2d2e27e5aeccb1c9bd5bcf734887db09e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.h
@@ -0,0 +1,181 @@
+/*
+ *  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 temporary_array.h
+ *  \brief Container-like class temporary storage inside algorithms.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// Forward declare temporary_array, as it's used by the CUDA copy backend, which
+// is included in contiguous_storage's definition.
+template<typename T, typename System>
+  class temporary_array;
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/detail/tagged_iterator.h>
+#include <thrust/detail/contiguous_storage.h>
+#include <thrust/detail/allocator/temporary_allocator.h>
+#include <thrust/detail/allocator/no_throw_allocator.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename T, typename System>
+  class temporary_array
+    : public contiguous_storage<
+               T,
+               no_throw_allocator<
+                 temporary_allocator<T,System>
+               >
+             >
+{
+  private:
+    typedef contiguous_storage<
+      T,
+      no_throw_allocator<
+        temporary_allocator<T,System>
+      >
+    > super_t;
+
+    // to help out the constructor
+    typedef no_throw_allocator<temporary_allocator<T,System> > alloc_type;
+
+  public:
+    typedef typename super_t::size_type size_type;
+
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system);
+
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system, size_type n);
+
+    // provide a kill-switch to explicitly avoid initialization
+    __host__ __device__
+    temporary_array(int uninit, thrust::execution_policy<System> &system, size_type n);
+
+    template<typename InputIterator>
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system,
+                    InputIterator first,
+                    size_type n);
+
+    template<typename InputIterator, typename InputSystem>
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system,
+                    thrust::execution_policy<InputSystem> &input_system,
+                    InputIterator first,
+                    size_type n);
+
+    template<typename InputIterator>
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system,
+                    InputIterator first,
+                    InputIterator last);
+
+    template<typename InputSystem, typename InputIterator>
+    __host__ __device__
+    temporary_array(thrust::execution_policy<System> &system,
+                    thrust::execution_policy<InputSystem> &input_system,
+                    InputIterator first,
+                    InputIterator last);
+
+    __host__ __device__
+    ~temporary_array();
+}; // end temporary_array
+
+
+// XXX eliminate this when we do ranges for real
+template<typename Iterator, typename System>
+  class tagged_iterator_range
+{
+  public:
+    typedef thrust::detail::tagged_iterator<Iterator,System> iterator;
+
+    template<typename Ignored1, typename Ignored2>
+    tagged_iterator_range(const Ignored1 &, const Ignored2 &, Iterator first, Iterator last)
+      : m_begin(first),
+        m_end(last)
+    {}
+
+    iterator begin(void) const { return m_begin; }
+    iterator end(void) const { return m_end; }
+
+  private:
+    iterator m_begin, m_end;
+};
+
+
+// if FromSystem is convertible to ToSystem, then just make a shallow
+// copy of the range. else, use a temporary_array
+// note that the resulting iterator is explicitly tagged with ToSystem either way
+template<typename Iterator, typename FromSystem, typename ToSystem>
+  struct move_to_system_base
+    : public eval_if<
+        is_convertible<
+          FromSystem,
+          ToSystem
+        >::value,
+        identity_<
+          tagged_iterator_range<Iterator,ToSystem>
+        >,
+        identity_<
+          temporary_array<
+            typename thrust::iterator_value<Iterator>::type,
+            ToSystem
+          >
+        >
+      >
+{};
+
+
+template<typename Iterator, typename FromSystem, typename ToSystem>
+  class move_to_system
+    : public move_to_system_base<
+        Iterator,
+        FromSystem,
+        ToSystem
+      >::type
+{
+  typedef typename move_to_system_base<Iterator,FromSystem,ToSystem>::type super_t;
+
+  public:
+    move_to_system(thrust::execution_policy<FromSystem> &from_system,
+                   thrust::execution_policy<ToSystem> &to_system,
+                   Iterator first,
+                   Iterator last)
+      : super_t(to_system, from_system, first, last) {}
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/temporary_array.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.inl
new file mode 100644
index 0000000000000000000000000000000000000000..90b7279ac6d4bc5e66e1d59c161b10749b64a65e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_array.inl
@@ -0,0 +1,168 @@
+/*
+ *  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>
+
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+namespace temporary_array_detail
+{
+
+
+template<typename T> struct avoid_initialization : thrust::detail::has_trivial_copy_constructor<T> {};
+
+
+template<typename T, typename TemporaryArray, typename Size>
+__host__ __device__
+typename thrust::detail::enable_if<
+  avoid_initialization<T>::value
+>::type
+  construct_values(TemporaryArray &,
+                   Size)
+{
+  // avoid the overhead of initialization
+} // end construct_values()
+
+
+template<typename T, typename TemporaryArray, typename Size>
+__host__ __device__
+typename thrust::detail::disable_if<
+  avoid_initialization<T>::value
+>::type
+  construct_values(TemporaryArray &a,
+                   Size n)
+{
+  a.default_construct_n(a.begin(), n);
+} // end construct_values()
+
+
+} // end temporary_array_detail
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(thrust::execution_policy<System> &system)
+      :super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(thrust::execution_policy<System> &system, size_type n)
+      :super_t(n, alloc_type(temporary_allocator<T,System>(system)))
+{
+  temporary_array_detail::construct_values<T>(*this, n);
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(int, thrust::execution_policy<System> &system, size_type n)
+      :super_t(n, alloc_type(temporary_allocator<T,System>(system)))
+{
+  // avoid initialization
+  ;
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        InputIterator first,
+                        size_type n)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(n);
+
+  super_t::uninitialized_copy_n(system, first, n, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator, typename InputSystem>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        thrust::execution_policy<InputSystem> &input_system,
+                        InputIterator first,
+                        size_type n)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(n);
+
+  super_t::uninitialized_copy_n(input_system, first, n, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        InputIterator first,
+                        InputIterator last)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(thrust::distance(first,last));
+
+  super_t::uninitialized_copy(system, first, last, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputSystem, typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        thrust::execution_policy<InputSystem> &input_system,
+                        InputIterator first,
+                        InputIterator last)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(thrust::distance(first,last));
+
+  super_t::uninitialized_copy(input_system, first, last, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::~temporary_array()
+{
+  // note that super_t::destroy will ignore trivial destructors automatically
+  super_t::destroy(super_t::begin(), super_t::end());
+} // end temporary_array::~temporary_array()
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_buffer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..be95e7180f5de84627cc2c9671aa56eee4f84d64
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/temporary_buffer.h
@@ -0,0 +1,75 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/execute_with_allocator.h>
+#include <thrust/system/detail/generic/temporary_buffer.h>
+#include <thrust/system/detail/adl/temporary_buffer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename T, typename DerivedPolicy, typename Pair>
+__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)));
+
+  typedef thrust::pair<thrust::pointer<T,DerivedPolicy>, typename thrust::pointer<T,DerivedPolicy>::difference_type> result_type;
+  return result_type(ptr, p.second);
+} // end down_cast_pair()
+
+
+} // end detail
+
+
+__thrust_exec_check_disable__
+template<typename T, typename DerivedPolicy>
+__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()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename Pointer>
+__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/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform.inl
new file mode 100644
index 0000000000000000000000000000000000000000..62bafd35ef029766c6630b3babf2af98bf86dc89
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform.inl
@@ -0,0 +1,247 @@
+/*
+ *  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>
+
+#include <thrust/transform.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform.h>
+#include <thrust/system/detail/adl/transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction>
+__host__ __device__
+  OutputIterator transform(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first, InputIterator last,
+                           OutputIterator result,
+                           UnaryFunction op)
+{
+  using thrust::system::detail::generic::transform;
+  return transform(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, op);
+} // end transform()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryFunction>
+__host__ __device__
+  OutputIterator transform(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1 first1, InputIterator1 last1,
+                           InputIterator2 first2,
+                           OutputIterator result,
+                           BinaryFunction op)
+{
+  using thrust::system::detail::generic::transform;
+  return transform(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, result, op);
+} // end transform()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator first, InputIterator last,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::transform_if;
+  return transform_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, op, pred);
+} // end transform_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator1 first, InputIterator1 last,
+                               InputIterator2 stencil,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::transform_if;
+  return transform_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, op, pred);
+} // end transform_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename ForwardIterator,
+         typename BinaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator1 first1, InputIterator1 last1,
+                               InputIterator2 first2,
+                               InputIterator3 stencil,
+                               ForwardIterator result,
+                               BinaryFunction binary_op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::transform_if;
+  return transform_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, stencil, result, binary_op, pred);
+} // end transform_if()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction>
+  OutputIterator transform(InputIterator first,
+                           InputIterator last,
+                           OutputIterator result,
+                           UnaryFunction op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform(select_system(system1,system2), first, last, result, op);
+} // end transform()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryFunction>
+  OutputIterator transform(InputIterator1 first1,
+                           InputIterator1 last1,
+                           InputIterator2 first2,
+                           OutputIterator result,
+                           BinaryFunction op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::transform(select_system(system1,system2,system3), first1, last1, first2, result, op);
+} // end transform()
+
+
+template<typename InputIterator,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator first,
+                               InputIterator last,
+                               ForwardIterator result,
+                               UnaryFunction unary_op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_if(select_system(system1,system2), first, last, result, unary_op, pred);
+} // end transform_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator1 first,
+                               InputIterator1 last,
+                               InputIterator2 stencil,
+                               ForwardIterator result,
+                               UnaryFunction unary_op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::transform_if(select_system(system1,system2,system3), first, last, stencil, result, unary_op, pred);
+} // end transform_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename ForwardIterator,
+         typename BinaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator1 first1,
+                               InputIterator1 last1,
+                               InputIterator2 first2,
+                               InputIterator3 stencil,
+                               ForwardIterator result,
+                               BinaryFunction binary_op,
+                               Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::transform_if(select_system(system1,system2,system3,system4), first1, last1, first2, stencil, result, binary_op, pred);
+} // end transform_if()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_reduce.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_reduce.inl
new file mode 100644
index 0000000000000000000000000000000000000000..702dd9f73b5a84943953ddd4fd0f280c25900403
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_reduce.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>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform_reduce.h>
+#include <thrust/system/detail/adl/transform_reduce.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename UnaryFunction,
+         typename OutputType,
+         typename BinaryFunction>
+__host__ __device__
+  OutputType transform_reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator first,
+                              InputIterator last,
+                              UnaryFunction unary_op,
+                              OutputType init,
+                              BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::transform_reduce;
+  return transform_reduce(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, unary_op, init, binary_op);
+} // end transform_reduce()
+
+
+template<typename InputIterator,
+         typename UnaryFunction,
+         typename OutputType,
+         typename BinaryFunction>
+  OutputType transform_reduce(InputIterator first,
+                              InputIterator last,
+                              UnaryFunction unary_op,
+                              OutputType init,
+                              BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::transform_reduce(select_system(system), first, last, unary_op, init, binary_op);
+} // end transform_reduce()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_scan.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_scan.inl
new file mode 100644
index 0000000000000000000000000000000000000000..957001cefd6db76bff13b359fe76668728f61940
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/transform_scan.inl
@@ -0,0 +1,117 @@
+/*
+ *  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>
+
+#include <thrust/scan.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/transform_scan.h>
+#include <thrust/system/detail/adl/transform_scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_inclusive_scan;
+  return transform_inclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::transform_exclusive_scan;
+  return transform_exclusive_scan(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename BinaryFunction>
+  OutputIterator transform_inclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          BinaryFunction binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_inclusive_scan(select_system(system1,system2), first, last, result, unary_op, binary_op);
+} // end transform_inclusive_scan()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+  OutputIterator transform_exclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::transform_exclusive_scan(select_system(system1,system2), first, last, result, unary_op, init, binary_op);
+} // end transform_exclusive_scan()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/trivial_sequence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/trivial_sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cf98e7872abb2fe64a4c87e21a7a474cd1c9e61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/trivial_sequence.h
@@ -0,0 +1,96 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file trivial_sequence.h
+ *  \brief Container-like class for wrapping sequences.  The wrapped
+ *         sequence always has trivial iterators, even when the input
+ *         sequence does not.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// never instantiated
+template<typename Iterator, typename DerivedPolicy, typename is_trivial> struct _trivial_sequence { };
+
+// trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::true_type>
+{
+    typedef Iterator iterator_type;
+    Iterator first, last;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &, Iterator _first, Iterator _last) : first(_first), last(_last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return first; }
+
+    __host__ __device__
+    iterator_type end()   { return last; }
+};
+
+// non-trivial case
+template<typename Iterator, typename DerivedPolicy>
+struct _trivial_sequence<Iterator, DerivedPolicy, thrust::detail::false_type>
+{
+    typedef typename thrust::iterator_value<Iterator>::type iterator_value;
+    typedef typename thrust::detail::temporary_array<iterator_value, DerivedPolicy>::iterator iterator_type;
+    
+    thrust::detail::temporary_array<iterator_value, DerivedPolicy> buffer;
+
+    __host__ __device__
+    _trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last)
+      : buffer(exec, first, last)
+    {
+    }
+
+    __host__ __device__
+    iterator_type begin() { return buffer.begin(); }
+
+    __host__ __device__
+    iterator_type end()   { return buffer.end(); }
+};
+
+template <typename Iterator, typename DerivedPolicy>
+struct trivial_sequence
+  : detail::_trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type>
+{
+    typedef _trivial_sequence<Iterator, DerivedPolicy, typename thrust::is_contiguous_iterator<Iterator>::type> super_t;
+
+    __host__ __device__
+    trivial_sequence(thrust::execution_policy<DerivedPolicy> &exec, Iterator first, Iterator last) : super_t(exec, first, last) { }
+};
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f4930bf4bd6cb80351fee479ea2e893a08e25a52
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple.inl
@@ -0,0 +1,1004 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/swap.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// define null_type
+struct null_type {};
+
+// null_type comparisons
+__host__ __device__ inline
+bool operator==(const null_type&, const null_type&) { return true; }
+
+__host__ __device__ inline
+bool operator>=(const null_type&, const null_type&) { return true; }
+
+__host__ __device__ inline
+bool operator<=(const null_type&, const null_type&) { return true; }
+
+__host__ __device__ inline
+bool operator!=(const null_type&, const null_type&) { return false; }
+
+__host__ __device__ inline
+bool operator<(const null_type&, const null_type&) { return false; }
+
+__host__ __device__ inline
+bool operator>(const null_type&, const null_type&) { return false; }
+
+// forward declaration for tuple
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type>
+class tuple;
+
+
+template <size_t N, class T> struct tuple_element;
+
+template<size_t N, class T>
+  struct tuple_element_impl
+{
+  private:
+    typedef typename T::tail_type Next;
+
+  public:
+    /*! The result of this metafunction is returned in \c type.
+     */
+    typedef typename tuple_element_impl<N-1, Next>::type type;
+}; // end tuple_element
+
+template<class T>
+  struct tuple_element_impl<0,T>
+{
+  typedef typename T::head_type type;
+};
+
+template <size_t N, class T>
+  struct tuple_element<N, T const>
+{
+    using type = typename std::add_const<typename tuple_element<N, T>::type>::type;
+};
+
+template <size_t N, class T>
+struct tuple_element<N, T volatile>
+{
+    using type = typename std::add_volatile<typename tuple_element<N, T>::type>::type;
+};
+
+template <size_t N, class T>
+  struct tuple_element<N, T const volatile>
+{
+    using type = typename std::add_cv<typename tuple_element<N, T>::type>::type;
+};
+
+template <size_t N, class T>
+struct tuple_element{
+    using type = typename tuple_element_impl<N,T>::type;
+};
+
+// forward declaration of tuple_size
+template<class T> struct tuple_size;
+
+template<class T>
+  struct tuple_size<T const> : public tuple_size<T> {};
+
+template<class T>
+  struct tuple_size<T volatile> : public tuple_size<T> {};
+
+template<class T>
+  struct tuple_size<T const volatile> : public tuple_size<T> {};
+
+/*! This metafunction returns the number of elements
+ *  of a \p tuple type of interest.
+ *
+ *  \tparam T A \c tuple type of interest.
+ *
+ *  \see pair
+ *  \see tuple
+ */
+template<class T>
+  struct tuple_size
+{
+  /*! The result of this metafunction is returned in \c value.
+   */
+  static const int value = 1 + tuple_size<typename T::tail_type>::value;
+}; // end tuple_size
+
+
+// specializations for tuple_size
+template<>
+  struct tuple_size< tuple<> >
+{
+  static const int value = 0;
+}; // end tuple_size< tuple<> >
+
+template<>
+  struct tuple_size<null_type>
+{
+  static const int value = 0;
+}; // end tuple_size<null_type>
+
+
+
+// forward declaration of detail::cons
+namespace detail
+{
+
+template <class HT, class TT> struct cons;
+
+} // end detail
+
+
+// -- some traits classes for get functions
+template <class T> struct access_traits
+{
+  typedef const T& const_type;
+  typedef T& non_const_type;
+
+  typedef const typename thrust::detail::remove_cv<T>::type& parameter_type;
+
+// used as the tuple constructors parameter types
+// Rationale: non-reference tuple element types can be cv-qualified.
+// It should be possible to initialize such types with temporaries,
+// and when binding temporaries to references, the reference must
+// be non-volatile and const. 8.5.3. (5)
+}; // end access_traits
+
+template <class T> struct access_traits<T&>
+{
+  typedef T& const_type;
+  typedef T& non_const_type;
+
+  typedef T& parameter_type;
+}; // end access_traits<T&>
+
+// forward declarations of get()
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::non_const_type
+// XXX we probably don't need to do this for any compiler we care about -jph
+//get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N));
+get(detail::cons<HT, TT>& c);
+
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::const_type
+// XXX we probably don't need to do this for any compiler we care about -jph
+//get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N));
+get(const detail::cons<HT, TT>& c);
+
+namespace detail
+{
+
+// -- generate error template, referencing to non-existing members of this
+// template is used to produce compilation errors intentionally
+template<class T>
+class generate_error;
+
+// - cons getters --------------------------------------------------------
+// called: get_class<N>::get<RETURN_TYPE>(aTuple)
+
+template< int N >
+struct get_class
+{
+  template<class RET, class HT, class TT >
+  __host__ __device__
+  inline static RET get(const cons<HT, TT>& t)
+  {
+    // XXX we may not need to deal with this for any compiler we care about -jph
+    //return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
+
+    // gcc 4.3 couldn't compile this:
+    //return get_class<N-1>::get<RET>(t.tail);
+  }
+
+  template<class RET, class HT, class TT >
+  __host__ __device__
+  inline static RET get(cons<HT, TT>& t)
+  {
+    // XXX we may not need to deal with this for any compiler we care about -jph
+    //return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
+    return get_class<N-1>::template get<RET>(t.tail);
+
+    // gcc 4.3 couldn't compile this:
+    //return get_class<N-1>::get<RET>(t.tail);
+  }
+}; // end get_class
+
+template<>
+struct get_class<0>
+{
+  template<class RET, class HT, class TT>
+  __host__ __device__
+  inline static RET get(const cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+
+  template<class RET, class HT, class TT>
+  __host__ __device__
+  inline static RET get(cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+}; // get get_class<0>
+
+
+template <bool If, class Then, class Else> struct IF
+{
+  typedef Then RET;
+};
+
+template <class Then, class Else> struct IF<false, Then, Else>
+{
+  typedef Else RET;
+};
+
+//  These helper templates wrap void types and plain function types.
+//  The rationale is to allow one to write tuple types with those types
+//  as elements, even though it is not possible to instantiate such object.
+//  E.g: typedef tuple<void> some_type; // ok
+//  but: some_type x; // fails
+
+template <class T> class non_storeable_type
+{
+  __host__ __device__
+  non_storeable_type();
+};
+
+template <class T> struct wrap_non_storeable_type
+{
+  // XXX is_function looks complicated; punt for now -jph
+  //typedef typename IF<
+  //  ::thrust::detail::is_function<T>::value, non_storeable_type<T>, T
+  //>::RET type;
+
+  typedef T type;
+};
+
+template <> struct wrap_non_storeable_type<void>
+{
+  typedef non_storeable_type<void> type;
+};
+
+
+template <class HT, class TT>
+  struct cons
+{
+  typedef HT head_type;
+  typedef TT tail_type;
+
+  typedef typename
+    wrap_non_storeable_type<head_type>::type stored_head_type;
+
+  stored_head_type head;
+  tail_type tail;
+
+  inline __host__ __device__
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  inline __host__ __device__
+  typename access_traits<tail_type>::non_const_type
+  get_tail() { return tail; }
+
+  inline __host__ __device__
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  inline __host__ __device__
+  typename access_traits<tail_type>::const_type
+  get_tail() const { return tail; }
+
+  inline __host__ __device__
+  cons(void) : head(), tail() {}
+  //  cons() : head(detail::default_arg<HT>::f()), tail() {}
+
+  // the argument for head is not strictly needed, but it prevents
+  // array type elements. This is good, since array type elements
+  // cannot be supported properly in any case (no assignment,
+  // copy works only if the tails are exactly the same type, ...)
+
+  inline __host__ __device__
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const tail_type& t)
+    : head (h), tail(t) {}
+
+  template <class T1, class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  inline __host__ __device__
+  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (t1),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, static_cast<const null_type&>(null_type()))
+      {}
+
+  template <class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  inline __host__ __device__
+  cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, static_cast<const null_type&>(null_type()))
+      {}
+
+
+  template <class HT2, class TT2>
+  inline __host__ __device__
+  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  cons(const cons &) = default;
+#endif
+
+  __thrust_exec_check_disable__
+  template <class HT2, class TT2>
+  inline __host__ __device__
+  cons& operator=( const cons<HT2, TT2>& u ) {
+    head=u.head; tail=u.tail; return *this;
+  }
+
+  // must define assignment operator explicitly, implicit version is
+  // illformed if HT is a reference (12.8. (12))
+  __thrust_exec_check_disable__
+  inline __host__ __device__
+  cons& operator=(const cons& u) {
+    head = u.head; tail = u.tail;  return *this;
+  }
+
+  // XXX enable when we support std::pair -jph
+  //template <class T1, class T2>
+  //__host__ __device__
+  //cons& operator=( const std::pair<T1, T2>& u ) {
+  //  //BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
+  //  head = u.first; tail.head = u.second; return *this;
+  //}
+
+  // get member functions (non-const and const)
+  template <int N>
+  __host__ __device__
+  typename access_traits<
+             typename tuple_element<N, cons<HT, TT> >::type
+           >::non_const_type
+  get() {
+    return thrust::get<N>(*this); // delegate to non-member get
+  }
+
+  template <int N>
+  __host__ __device__
+  typename access_traits<
+             typename tuple_element<N, cons<HT, TT> >::type
+           >::const_type
+  get() const {
+    return thrust::get<N>(*this); // delegate to non-member get
+  }
+
+  inline __host__ __device__
+  void swap(cons &c)
+  {
+    using thrust::swap;
+
+    swap(head, c.head);
+    tail.swap(c.tail);
+  }
+};
+
+template <class HT>
+  struct cons<HT, null_type>
+{
+  typedef HT head_type;
+  typedef null_type tail_type;
+  typedef cons<HT, null_type> self_type;
+
+  typedef typename
+    wrap_non_storeable_type<head_type>::type stored_head_type;
+  stored_head_type head;
+
+  typename access_traits<stored_head_type>::non_const_type
+  inline __host__ __device__
+  get_head() { return head; }
+
+  inline __host__ __device__
+  null_type get_tail() { return null_type(); }
+
+  inline __host__ __device__
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  inline __host__ __device__
+  null_type get_tail() const { return null_type(); }
+
+  inline __host__ __device__
+  cons() : head() {}
+
+  inline __host__ __device__
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const null_type& = null_type())
+    : head (h) {}
+
+  template<class T1>
+  inline __host__ __device__
+  cons(T1& t1, const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head (t1) {}
+
+  inline __host__ __device__
+  cons(const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
+  template <class HT2>
+  inline __host__ __device__
+  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  cons(const cons &) = default;
+#endif
+
+  __thrust_exec_check_disable__
+  template <class HT2>
+  inline __host__ __device__
+  cons& operator=(const cons<HT2, null_type>& u )
+  {
+    head = u.head;
+    return *this;
+  }
+
+  // must define assignment operator explicitly, implicit version
+  // is illformed if HT is a reference
+  inline __host__ __device__
+  cons& operator=(const cons& u) { head = u.head; return *this; }
+
+  template <int N>
+  inline __host__ __device__
+  typename access_traits<
+             typename tuple_element<N, self_type>::type
+            >::non_const_type
+  // XXX we probably don't need this for the compilers we care about -jph
+  //get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N))
+  get(void)
+  {
+    return thrust::get<N>(*this);
+  }
+
+  template <int N>
+  inline __host__ __device__
+  typename access_traits<
+             typename tuple_element<N, self_type>::type
+           >::const_type
+  // XXX we probably don't need this for the compilers we care about -jph
+  //get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const
+  get(void) const
+  {
+    return thrust::get<N>(*this);
+  }
+
+  inline __host__ __device__
+  void swap(cons &c)
+  {
+    using thrust::swap;
+
+    swap(head, c.head);
+  }
+}; // end cons
+
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+  struct map_tuple_to_cons
+{
+  typedef cons<T0,
+               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
+                                          T6, T7, T8, T9, null_type>::type
+              > type;
+}; // end map_tuple_to_cons
+
+// The empty tuple is a null_type
+template <>
+  struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
+{
+  typedef null_type type;
+}; // end map_tuple_to_cons<...>
+
+
+
+// ---------------------------------------------------------------------------
+// The call_traits for make_tuple
+
+// Must be instantiated with plain or const plain types (not with references)
+
+// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
+// from template<class T> foo(T& t) : make_tuple_traits<T>::type
+
+// Conversions:
+// T -> T,
+// references -> compile_time_error
+// array -> const ref array
+
+
+template<class T>
+struct make_tuple_traits {
+  typedef T type;
+
+  // commented away, see below  (JJ)
+  //  typedef typename IF<
+  //  boost::is_function<T>::value,
+  //  T&,
+  //  T>::RET type;
+
+};
+
+// The is_function test was there originally for plain function types,
+// which can't be stored as such (we must either store them as references or
+// pointers). Such a type could be formed if make_tuple was called with a
+// reference to a function.
+// But this would mean that a const qualified function type was formed in
+// the make_tuple function and hence make_tuple can't take a function
+// reference as a parameter, and thus T can't be a function type.
+// So is_function test was removed.
+// (14.8.3. says that type deduction fails if a cv-qualified function type
+// is created. (It only applies for the case of explicitly specifying template
+// args, though?)) (JJ)
+
+template<class T>
+struct make_tuple_traits<T&> {
+  typedef typename
+     detail::generate_error<T&>::
+       do_not_use_with_reference_type error;
+};
+
+// Arrays can't be stored as plain types; convert them to references.
+// All arrays are converted to const. This is because make_tuple takes its
+// parameters as const T& and thus the knowledge of the potential
+// non-constness of actual argument is lost.
+template<class T, int n>  struct make_tuple_traits <T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+// XXX enable these if we ever care about reference_wrapper -jph
+//template<class T>
+//struct make_tuple_traits<reference_wrapper<T> >{
+//  typedef T& type;
+//};
+//
+//template<class T>
+//struct make_tuple_traits<const reference_wrapper<T> >{
+//  typedef T& type;
+//};
+
+
+// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
+// suggestion)
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type
+>
+struct make_tuple_mapper {
+  typedef
+    tuple<typename make_tuple_traits<T0>::type,
+          typename make_tuple_traits<T1>::type,
+          typename make_tuple_traits<T2>::type,
+          typename make_tuple_traits<T3>::type,
+          typename make_tuple_traits<T4>::type,
+          typename make_tuple_traits<T5>::type,
+          typename make_tuple_traits<T6>::type,
+          typename make_tuple_traits<T7>::type,
+          typename make_tuple_traits<T8>::type,
+          typename make_tuple_traits<T9>::type> type;
+};
+
+} // end detail
+
+
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::non_const_type
+get(detail::cons<HT, TT>& c)
+{
+  //return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+
+  // gcc 4.3 couldn't compile this:
+  //return detail::get_class<N>::
+
+  return detail::get_class<N>::template
+         get<
+           typename access_traits<
+             typename tuple_element<N, detail::cons<HT, TT> >::type
+           >::non_const_type,
+           HT,TT
+         >(c);
+}
+
+
+// get function for const cons-lists, returns a const reference to
+// the element. If the element is a reference, returns the reference
+// as such (that is, can return a non-const reference)
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::const_type
+get(const detail::cons<HT, TT>& c)
+{
+  //return detail::get_class<N>::BOOST_NESTED_TEMPLATE
+
+  // gcc 4.3 couldn't compile this:
+  //return detail::get_class<N>::
+
+  return detail::get_class<N>::template
+         get<
+           typename access_traits<
+             typename tuple_element<N, detail::cons<HT, TT> >::type
+           >::const_type,
+           HT,TT
+         >(c);
+}
+
+
+template<class T0>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0>::type
+    make_tuple(const T0& t0)
+{
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
+} // end make_tuple()
+
+template<class T0, class T1>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1>::type
+    make_tuple(const T0& t0, const T1& t1)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1>::type t;
+  return t(t0,t1);
+} // end make_tuple()
+
+template<class T0, class T1, class T2>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2>::type t;
+  return t(t0,t1,t2);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3>::type t;
+  return t(t0,t1,t2,t3);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4>::type t;
+  return t(t0,t1,t2,t3,t4);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4,T5>::type t;
+  return t(t0,t1,t2,t3,t4,t5);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4,T5,T6>::type t;
+  return t(t0,t1,t2,t3,t4,t5,t6);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4,T5,T6,T7>::type t;
+  return t(t0,t1,t2,t3,t4,t5,t6,t7);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4,T5,T6,T7,T8>::type t;
+  return t(t0,t1,t2,t3,t4,t5,t6,t7,t8);
+} // end make_tuple()
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
+{
+  typedef typename detail::make_tuple_mapper<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>::type t;
+  return t(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9);
+} // end make_tuple()
+
+
+template<typename T0>
+__host__ __device__ inline
+tuple<T0&> tie(T0 &t0)
+{
+  return tuple<T0&>(t0);
+}
+
+template<typename T0,typename T1>
+__host__ __device__ inline
+tuple<T0&,T1&> tie(T0 &t0, T1 &t1)
+{
+  return tuple<T0&,T1&>(t0,t1);
+}
+
+template<typename T0,typename T1, typename T2>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&> tie(T0 &t0, T1 &t1, T2 &t2)
+{
+  return tuple<T0&,T1&,T2&>(t0,t1,t2);
+}
+
+template<typename T0,typename T1, typename T2, typename T3>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3)
+{
+  return tuple<T0&,T1&,T2&,T3&>(t0,t1,t2,t3);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&>(t0,t1,t2,t3,t4);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4, typename T5>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&,T5&>(t0,t1,t2,t3,t4,t5);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&>(t0,t1,t2,t3,t4,t5,t6);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&>(t0,t1,t2,t3,t4,t5,t6,t7);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&>(t0,t1,t2,t3,t4,t5,t6,t7,t8);
+}
+
+template<typename T0,typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&,T9&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
+{
+  return tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&,T9&>(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9);
+}
+
+template<
+  typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9,
+  typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9
+>
+__host__ __device__ inline
+void swap(thrust::tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> &x,
+          thrust::tuple<U0,U1,U2,U3,U4,U5,U6,U7,U8,U9> &y)
+{
+  return x.swap(y);
+}
+
+
+
+namespace detail
+{
+
+template<class T1, class T2>
+__host__ __device__
+inline bool eq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() == rhs.get_head() &&
+         eq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+__host__ __device__
+inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+__host__ __device__
+inline bool neq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() != rhs.get_head()  ||
+         neq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+__host__ __device__
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+__host__ __device__
+inline bool lt(const T1& lhs, const T2& rhs) {
+  return (lhs.get_head() < rhs.get_head())  ||
+            (!(rhs.get_head() < lhs.get_head()) &&
+             lt(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+__host__ __device__
+inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+__host__ __device__
+inline bool gt(const T1& lhs, const T2& rhs) {
+  return (lhs.get_head() > rhs.get_head())  ||
+            (!(rhs.get_head() > lhs.get_head()) &&
+             gt(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+__host__ __device__
+inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+__host__ __device__
+inline bool lte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() <= rhs.get_head()  &&
+          ( !(rhs.get_head() <= lhs.get_head()) ||
+            lte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+__host__ __device__
+inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+__host__ __device__
+inline bool gte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() >= rhs.get_head()  &&
+          ( !(rhs.get_head() >= lhs.get_head()) ||
+            gte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+__host__ __device__
+inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+} // end detail
+
+
+
+// equal ----
+
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator==(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return  detail::eq(lhs, rhs);
+} // end operator==()
+
+// not equal -----
+
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator!=(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return detail::neq(lhs, rhs);
+} // end operator!=()
+
+// <
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator<(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return detail::lt(lhs, rhs);
+} // end operator<()
+
+// >
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator>(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return detail::gt(lhs, rhs);
+} // end operator>()
+
+// <=
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator<=(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return detail::lte(lhs, rhs);
+} // end operator<=()
+
+// >=
+template<class T1, class T2, class S1, class S2>
+__host__ __device__
+inline bool operator>=(const detail::cons<T1, T2>& lhs, const detail::cons<S1, S2>& rhs)
+{
+  // XXX support this eventually -jph
+  //// check that tuple lengths are equal
+  //BOOST_STATIC_ASSERT(tuple_size<T2>::value == tuple_size<S2>::value);
+
+  return detail::gte(lhs, rhs);
+} // end operator>=()
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_algorithms.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_algorithms.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e49f4281f3f2dea8f1e5a2f4da3f0b3ffde4be8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_algorithms.h
@@ -0,0 +1,110 @@
+/*
+ *  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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+#include <tuple>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename Tuple, std::size_t... Is>
+auto tuple_subset(Tuple&& t, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(std::get<Is>(THRUST_FWD(t))...));
+
+namespace detail
+{
+
+template <typename Tuple, typename F, std::size_t... Is>
+void tuple_for_each_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+{
+  auto l = { (f(std::get<Is>(t)), 0)... };
+  THRUST_UNUSED_VAR(l);
+}
+
+template <typename Tuple, typename F, std::size_t... Is>
+auto tuple_transform_impl(Tuple&& t, F&& f, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(std::make_tuple(f(std::get<Is>(t))...));
+
+} // namespace detail
+
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_for_each(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_for_each_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...> const& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    t
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+template <typename... Ts, typename F>
+auto tuple_transform(std::tuple<Ts...>&& t, F&& f)
+THRUST_DECLTYPE_RETURNS(
+  detail::tuple_transform_impl(
+    std::move(t)
+  , THRUST_FWD(f)
+  , make_index_sequence<sizeof...(Ts)>{}
+  )
+);
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_meta_transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_meta_transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..285cae8b4c727ad550c155e52a62bbe05c57ff81
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_meta_transform.h
@@ -0,0 +1,58 @@
+/*
+ *  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>
+
+#include <thrust/tuple.h>
+#include <thrust/type_traits/integer_sequence.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// introduce an intermediate type tuple_meta_transform_WAR_NVCC
+// rather than directly specializing tuple_meta_transform with
+// default argument IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>
+// to workaround nvcc 11.0 compiler bug
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename IndexSequence>
+  struct tuple_meta_transform_WAR_NVCC;
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         size_t... Is>
+  struct tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::index_sequence<Is...>>
+{
+  typedef thrust::tuple<
+    typename UnaryMetaFunction<typename thrust::tuple_element<Is,Tuple>::type>::type...
+  > type;
+};
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction>
+  struct tuple_meta_transform
+{
+  typedef typename tuple_meta_transform_WAR_NVCC<Tuple, UnaryMetaFunction, thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>::type type;
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..1011d5179e31e1fe15a38431eccff1f3d714888a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/tuple_transform.h
@@ -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>
+
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         typename IndexSequence = thrust::make_index_sequence<thrust::tuple_size<Tuple>::value>>
+  struct tuple_transform_functor;
+
+
+template<typename Tuple,
+         template<typename> class UnaryMetaFunction,
+         typename UnaryFunction,
+         size_t... Is>
+  struct tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction,thrust::index_sequence<Is...>>
+{
+  static __host__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+
+  static __host__ __device__
+  typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+  do_it_on_the_host_or_device(const Tuple &t, UnaryFunction f)
+  {
+    typedef typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type XfrmTuple;
+
+    return XfrmTuple(f(thrust::get<Is>(t))...);
+  }
+};
+
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+tuple_host_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host(t,f);
+}
+
+template<template<typename> class UnaryMetaFunction,
+         typename Tuple,
+         typename UnaryFunction>
+typename tuple_meta_transform<Tuple,UnaryMetaFunction>::type
+__host__ __device__
+tuple_host_device_transform(const Tuple &t, UnaryFunction f)
+{
+  return tuple_transform_functor<Tuple,UnaryMetaFunction,UnaryFunction>::do_it_on_the_host_or_device(t,f);
+}
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_deduction.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_deduction.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f240711d0a132166fdb0dee4de775854d9bec2b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_deduction.h
@@ -0,0 +1,90 @@
+// 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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/preprocessor.h>
+
+#include <utility>
+#include <type_traits>
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// \def THRUST_FWD(x)
+/// \brief Performs universal forwarding of a universal reference.
+///
+#define THRUST_FWD(x) ::std::forward<decltype(x)>(x)
+
+/// \def THRUST_MVCAP(x)
+/// \brief Capture `x` into a lambda by moving.
+///
+#define THRUST_MVCAP(x) x = ::std::move(x)
+
+/// \def THRUST_RETOF(invocable, ...)
+/// \brief Expands to the type returned by invoking an instance of the invocable
+///        type \a invocable with parameters of type \c __VA_ARGS__. Must
+///        be called with 1 or fewer parameters to the invocable.
+///
+#define THRUST_RETOF(...)   THRUST_PP_DISPATCH(THRUST_RETOF, __VA_ARGS__)
+#define THRUST_RETOF1(C)    decltype(::std::declval<C>()())
+#define THRUST_RETOF2(C, V) decltype(::std::declval<C>()(::std::declval<V>()))
+
+/// \def THRUST_RETURNS(...)
+/// \brief Expands to a function definition that returns the expression
+///        \c __VA_ARGS__.
+///
+#define THRUST_RETURNS(...)                                                   \
+  noexcept(noexcept(__VA_ARGS__))                                             \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+
+/// \def THRUST_DECLTYPE_RETURNS(...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> decltype(__VA_ARGS__)                                                  \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+/// \def THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)
+/// \brief Expands to a function definition, including a trailing returning
+///        type, that returns the expression \c __VA_ARGS__. It shall only
+///        participate in overload resolution if \c condition is \c true.
+///
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+  #define THRUST_DECLTYPE_RETURNS(...)                                        \
+  { return (__VA_ARGS__); }                                                   \
+  /**/
+#else
+  #define THRUST_DECLTYPE_RETURNS_WITH_SFINAE_CONDITION(condition, ...)       \
+    noexcept(noexcept(__VA_ARGS__))                                           \
+    -> typename std::enable_if<condition, decltype(__VA_ARGS__)>::type        \
+    { return (__VA_ARGS__); }                                                 \
+    /**/
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..f25eaeaf050a8af6498330413bfb4b514a880d27
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits.h
@@ -0,0 +1,717 @@
+/*
+ *  Copyright 2008-2022 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file type_traits.h
+ *  \brief Temporarily define some type traits
+ *         until nvcc can compile tr1::type_traits.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <cuda/std/type_traits>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of device_reference
+template<typename T> class device_reference;
+
+namespace detail
+{
+ /// helper classes [4.3].
+ template<typename T, T v>
+   struct integral_constant
+   {
+     THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT T value = v;
+
+     typedef T                       value_type;
+     typedef integral_constant<T, v> type;
+
+     // We don't want to switch to std::integral_constant, because we want access
+     // to the C++14 operator(), but we'd like standard traits to interoperate
+     // with our version when tag dispatching.
+     integral_constant() = default;
+
+     integral_constant(integral_constant const&) = default;
+
+     integral_constant& operator=(integral_constant const&) = default;
+
+     constexpr __host__ __device__
+     integral_constant(std::integral_constant<T, v>) noexcept {}
+
+     constexpr __host__ __device__ operator value_type() const noexcept { return value; }
+     constexpr __host__ __device__ value_type operator()() const noexcept { return value; }
+   };
+ 
+ /// typedef for true_type
+ typedef integral_constant<bool, true>  true_type;
+
+ /// typedef for true_type
+ typedef integral_constant<bool, false> false_type;
+
+//template<typename T> struct is_integral : public std::tr1::is_integral<T> {};
+template<typename T> struct is_integral                           : public false_type {};
+template<>           struct is_integral<bool>                     : public true_type {};
+template<>           struct is_integral<char>                     : public true_type {};
+template<>           struct is_integral<signed char>              : public true_type {};
+template<>           struct is_integral<unsigned char>            : public true_type {};
+template<>           struct is_integral<short>                    : public true_type {};
+template<>           struct is_integral<unsigned short>           : public true_type {};
+template<>           struct is_integral<int>                      : public true_type {};
+template<>           struct is_integral<unsigned int>             : public true_type {};
+template<>           struct is_integral<long>                     : public true_type {};
+template<>           struct is_integral<unsigned long>            : public true_type {};
+template<>           struct is_integral<long long>                : public true_type {};
+template<>           struct is_integral<unsigned long long>       : public true_type {};
+template<>           struct is_integral<const bool>               : public true_type {};
+template<>           struct is_integral<const char>               : public true_type {};
+template<>           struct is_integral<const unsigned char>      : public true_type {};
+template<>           struct is_integral<const short>              : public true_type {};
+template<>           struct is_integral<const unsigned short>     : public true_type {};
+template<>           struct is_integral<const int>                : public true_type {};
+template<>           struct is_integral<const unsigned int>       : public true_type {};
+template<>           struct is_integral<const long>               : public true_type {};
+template<>           struct is_integral<const unsigned long>      : public true_type {};
+template<>           struct is_integral<const long long>          : public true_type {};
+template<>           struct is_integral<const unsigned long long> : public true_type {};
+
+template<typename T> struct is_floating_point              : public false_type {};
+template<>           struct is_floating_point<float>       : public true_type {};
+template<>           struct is_floating_point<double>      : public true_type {};
+template<>           struct is_floating_point<long double> : public true_type {};
+
+template<typename T> struct is_arithmetic               : public is_integral<T> {};
+template<>           struct is_arithmetic<float>        : public true_type {};
+template<>           struct is_arithmetic<double>       : public true_type {};
+template<>           struct is_arithmetic<const float>  : public true_type {};
+template<>           struct is_arithmetic<const double> : public true_type {};
+
+template<typename T> struct is_pointer      : public false_type {};
+template<typename T> struct is_pointer<T *> : public true_type  {};
+
+template<typename T> struct is_device_ptr  : public false_type {};
+
+template<typename T> struct is_void             : public false_type {};
+template<>           struct is_void<void>       : public true_type {};
+template<>           struct is_void<const void> : public true_type {};
+
+template<typename T> struct is_non_bool_integral       : public is_integral<T> {};
+template<>           struct is_non_bool_integral<bool> : public false_type {};
+
+template<typename T> struct is_non_bool_arithmetic       : public is_arithmetic<T> {};
+template<>           struct is_non_bool_arithmetic<bool> : public false_type {};
+
+template<typename T> struct is_pod
+   : public integral_constant<
+       bool,
+       is_void<T>::value || is_pointer<T>::value || is_arithmetic<T>::value
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC || \
+    THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+// use intrinsic type traits
+       || __is_pod(T)
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+// only use the intrinsic for >= 4.3
+#if (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
+       || __is_pod(T)
+#endif // GCC VERSION
+#endif // THRUST_HOST_COMPILER
+     >
+ {};
+
+
+template <typename T> 
+struct has_trivial_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_constructible<T>::value> 
+{};
+
+template<typename T> 
+struct has_trivial_copy_constructor
+  : public integral_constant<bool, is_pod<T>::value || ::cuda::std::is_trivially_copyable<T>::value>
+{};
+
+template<typename T> struct has_trivial_destructor : public is_pod<T> {};
+
+template<typename T> struct is_const          : public false_type {};
+template<typename T> struct is_const<const T> : public true_type {};
+
+template<typename T> struct is_volatile             : public false_type {};
+template<typename T> struct is_volatile<volatile T> : public true_type {};
+
+template<typename T>
+  struct add_const
+{
+  typedef T const type;
+}; // end add_const
+
+template<typename T>
+  struct remove_const
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct remove_const<const T>
+{
+  typedef T type;
+}; // end remove_const
+
+template<typename T>
+  struct add_volatile
+{
+  typedef volatile T type;
+}; // end add_volatile
+
+template<typename T>
+  struct remove_volatile
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct remove_volatile<volatile T>
+{
+  typedef T type;
+}; // end remove_volatile
+
+template<typename T>
+  struct add_cv
+{
+  typedef const volatile T type;
+}; // end add_cv
+
+template<typename T>
+  struct remove_cv
+{
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+}; // end remove_cv
+
+
+template<typename T> struct is_reference     : public false_type {};
+template<typename T> struct is_reference<T&> : public true_type {};
+
+template<typename T> struct is_proxy_reference  : public false_type {};
+
+template<typename T> struct is_device_reference                                : public false_type {};
+template<typename T> struct is_device_reference< thrust::device_reference<T> > : public true_type {};
+
+
+// NB: Careful with reference to void.
+template<typename _Tp, bool = (is_void<_Tp>::value || is_reference<_Tp>::value)>
+  struct __add_reference_helper
+  { typedef _Tp&    type; };
+
+template<typename _Tp>
+  struct __add_reference_helper<_Tp, true>
+  { typedef _Tp     type; };
+
+template<typename _Tp>
+  struct add_reference
+    : public __add_reference_helper<_Tp>{};
+
+template<typename T>
+  struct remove_reference
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T>
+  struct remove_reference<T&>
+{
+  typedef T type;
+}; // end remove_reference
+
+template<typename T1, typename T2>
+  struct is_same
+    : public false_type
+{
+}; // end is_same
+
+template<typename T>
+  struct is_same<T,T>
+    : public true_type
+{
+}; // end is_same
+
+template<typename T1, typename T2>
+  struct lazy_is_same
+    : is_same<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_same
+
+template<typename T1, typename T2>
+  struct is_different
+    : public true_type
+{
+}; // end is_different
+
+template<typename T>
+  struct is_different<T,T>
+    : public false_type
+{
+}; // end is_different
+
+template<typename T1, typename T2>
+  struct lazy_is_different
+    : is_different<typename T1::type, typename T2::type>
+{
+}; // end lazy_is_different
+
+#if THRUST_CPP_DIALECT >= 2011
+
+using std::is_convertible;
+
+#else
+
+namespace tt_detail
+{
+
+template<typename T>
+  struct is_int_or_cref
+{
+  typedef typename remove_reference<T>::type type_sans_ref;
+  static const bool value = (is_integral<T>::value
+                             || (is_integral<type_sans_ref>::value
+                                 && is_const<type_sans_ref>::value
+                                 && !is_volatile<type_sans_ref>::value));
+}; // end is_int_or_cref
+
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN
+
+template<typename From, typename To>
+  struct is_convertible_sfinae
+{
+  private:
+    typedef char                          yes;
+    typedef struct { char two_chars[2]; } no;
+
+    static inline yes   test(To) { return yes(); }
+    static inline no    test(...) { return no(); } 
+    static inline typename remove_reference<From>::type& from() { typename remove_reference<From>::type* ptr = 0; return *ptr; }
+
+  public:
+    static const bool value = sizeof(test(from())) == sizeof(yes);
+}; // end is_convertible_sfinae
+
+
+THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+
+
+template<typename From, typename To>
+  struct is_convertible_needs_simple_test
+{
+  static const bool from_is_void      = is_void<From>::value;
+  static const bool to_is_void        = is_void<To>::value;
+  static const bool from_is_float     = is_floating_point<typename remove_reference<From>::type>::value;
+  static const bool to_is_int_or_cref = is_int_or_cref<To>::value;
+
+  static const bool value = (from_is_void || to_is_void || (from_is_float && to_is_int_or_cref));
+}; // end is_convertible_needs_simple_test
+
+
+template<typename From, typename To,
+         bool = is_convertible_needs_simple_test<From,To>::value>
+  struct is_convertible
+{
+  static const bool value = (is_void<To>::value
+                             || (is_int_or_cref<To>::value
+                                 && !is_void<From>::value));
+}; // end is_convertible
+
+
+template<typename From, typename To>
+  struct is_convertible<From, To, false>
+{
+  static const bool value = (is_convertible_sfinae<typename
+                             add_reference<From>::type, To>::value);
+}; // end is_convertible
+
+
+} // end tt_detail
+
+template<typename From, typename To>
+  struct is_convertible
+    : public integral_constant<bool, tt_detail::is_convertible<From, To>::value>
+{
+}; // end is_convertible
+
+#endif
+
+template<typename T1, typename T2>
+  struct is_one_convertible_to_the_other
+    : public integral_constant<
+        bool,
+        is_convertible<T1,T2>::value || is_convertible<T2,T1>::value
+      >
+{};
+
+
+// mpl stuff
+template<typename... Conditions>
+  struct or_;
+
+template <>
+  struct or_<>
+    : public integral_constant<
+        bool,
+        false_type::value  // identity for or_
+      >
+{
+}; // end or_
+
+template <typename Condition, typename... Conditions>
+  struct or_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value || or_<Conditions...>::value
+      >
+{
+}; // end or_
+
+template <typename... Conditions>
+  struct and_;
+
+template<>
+  struct and_<>
+    : public integral_constant<
+        bool,
+        true_type::value // identity for and_
+      >
+{
+}; // end and_
+
+template <typename Condition, typename... Conditions>
+  struct and_<Condition, Conditions...>
+    : public integral_constant<
+        bool,
+        Condition::value && and_<Conditions...>::value>
+{
+}; // end and_
+
+template <typename Boolean>
+  struct not_
+    : public integral_constant<bool, !Boolean::value>
+{
+}; // end not_
+
+template<bool B, class T, class F>
+struct conditional { typedef T type; };
+ 
+template<class T, class F>
+struct conditional<false, T, F> { typedef F type; };
+
+template <bool, typename Then, typename Else>
+  struct eval_if
+{
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<true, Then, Else>
+{
+  typedef typename Then::type type;
+}; // end eval_if
+
+template<typename Then, typename Else>
+  struct eval_if<false, Then, Else>
+{
+  typedef typename Else::type type;
+}; // end eval_if
+
+template<typename T>
+//  struct identity
+//  XXX WAR nvcc's confusion with thrust::identity
+  struct identity_
+{
+  typedef T type;
+}; // end identity
+
+template<bool, typename T = void> struct enable_if {};
+template<typename T>              struct enable_if<true, T> {typedef T type;};
+
+template<bool, typename T> struct lazy_enable_if {};
+template<typename T>       struct lazy_enable_if<true, T> {typedef typename T::type type;};
+
+template<bool condition, typename T = void> struct disable_if : enable_if<!condition, T> {};
+template<bool condition, typename T>        struct lazy_disable_if : lazy_enable_if<!condition, T> {};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct enable_if_convertible
+    : enable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename T = void>
+  struct disable_if_convertible
+    : disable_if< is_convertible<T1,T2>::value, T >
+{};
+
+
+template<typename T1, typename T2, typename Result = void>
+  struct enable_if_different
+    : enable_if<is_different<T1,T2>::value, Result>
+{};
+
+
+template<typename T>
+  struct is_numeric
+    : and_<
+        is_convertible<int,T>,
+        is_convertible<T,int>
+      >
+{
+}; // end is_numeric
+
+
+template<typename> struct is_reference_to_const             : false_type {};
+template<typename T> struct is_reference_to_const<const T&> : true_type {};
+
+
+// make_unsigned follows
+
+namespace tt_detail
+{
+
+template<typename T> struct make_unsigned_simple;
+
+template<> struct make_unsigned_simple<char>                   { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<signed char>            { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<unsigned char>          { typedef unsigned char          type; };
+template<> struct make_unsigned_simple<short>                  { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<unsigned short>         { typedef unsigned short         type; };
+template<> struct make_unsigned_simple<int>                    { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<unsigned int>           { typedef unsigned int           type; };
+template<> struct make_unsigned_simple<long int>               { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<unsigned long int>      { typedef unsigned long int      type; };
+template<> struct make_unsigned_simple<long long int>          { typedef unsigned long long int type; };
+template<> struct make_unsigned_simple<unsigned long long int> { typedef unsigned long long int type; };
+
+template<typename T>
+  struct make_unsigned_base
+{
+  // remove cv
+  typedef typename remove_cv<T>::type remove_cv_t;
+
+  // get the simple unsigned type
+  typedef typename make_unsigned_simple<remove_cv_t>::type unsigned_remove_cv_t;
+
+  // add back const, volatile, both, or neither to the simple result
+  typedef typename eval_if<
+    is_const<T>::value && is_volatile<T>::value,
+    // add cv back
+    add_cv<unsigned_remove_cv_t>,
+    // check const & volatile individually
+    eval_if<
+      is_const<T>::value,
+      // add c back
+      add_const<unsigned_remove_cv_t>,
+      eval_if<
+        is_volatile<T>::value,
+        // add v back
+        add_volatile<unsigned_remove_cv_t>,
+        // original type was neither cv, return the simple unsigned result
+        identity_<unsigned_remove_cv_t>
+      >
+    >
+  >::type type;
+};
+
+} // end tt_detail
+
+template<typename T>
+  struct make_unsigned
+    : tt_detail::make_unsigned_base<T>
+{};
+
+struct largest_available_float
+{
+  typedef double type;
+};
+
+// T1 wins if they are both the same size
+template<typename T1, typename T2>
+  struct larger_type
+    : thrust::detail::eval_if<
+        (sizeof(T2) > sizeof(T1)),
+        thrust::detail::identity_<T2>,
+        thrust::detail::identity_<T1>
+      >
+{};
+
+#if THRUST_CPP_DIALECT >= 2011
+
+using std::is_base_of;
+
+#else
+
+namespace is_base_of_ns
+{
+
+typedef char                          yes;
+typedef struct { char two_chars[2]; } no;
+
+template<typename Base, typename Derived>
+  struct host
+{
+  operator Base*() const;
+  operator Derived*();
+}; // end host
+
+template<typename Base, typename Derived>
+  struct impl
+{
+  template<typename T> static yes check(Derived *, T);
+  static no check(Base*, int);
+
+  static const bool value = sizeof(check(host<Base,Derived>(), int())) == sizeof(yes);
+}; // end impl
+
+} // end is_base_of_ns
+
+
+template<typename Base, typename Derived>
+  struct is_base_of
+    : integral_constant<
+        bool,
+        is_base_of_ns::impl<Base,Derived>::value
+      >
+{};
+
+#endif
+
+template<typename Base, typename Derived, typename Result = void>
+  struct enable_if_base_of
+    : enable_if<
+        is_base_of<Base,Derived>::value,
+        Result
+      >
+{};
+
+
+namespace is_assignable_ns
+{
+
+template<typename T1, typename T2>
+  class is_assignable
+{
+  typedef char                      yes_type;
+  typedef struct { char array[2]; } no_type;
+
+  template<typename T> static typename add_reference<T>::type declval();
+  
+  template<size_t> struct helper { typedef void * type; };
+
+  template<typename U1, typename U2> static yes_type test(typename helper<sizeof(declval<U1>() = declval<U2>())>::type);
+
+  template<typename,typename> static no_type test(...);
+
+  public:
+    static const bool value = sizeof(test<T1,T2>(0)) == 1;
+}; // end is_assignable
+
+} // end is_assignable_ns
+
+
+template<typename T1, typename T2>
+  struct is_assignable
+    : integral_constant<
+        bool,
+        is_assignable_ns::is_assignable<T1,T2>::value
+      >
+{};
+
+
+template<typename T>
+  struct is_copy_assignable
+    : is_assignable<
+        typename add_reference<T>::type,
+        typename add_reference<typename add_const<T>::type>::type
+      >
+{};
+
+
+template<typename T1, typename T2, typename Enable = void> struct promoted_numerical_type;
+
+template<typename T1, typename T2> 
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type,typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef typename larger_type<T1,T2>::type type;
+  };
+
+template<typename T1, typename T2> 
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_integral<T1>::type,typename is_floating_point<T2>::type>
+  ::value>::type>
+  {
+  typedef T2 type;
+  };
+
+template<typename T1, typename T2>
+  struct promoted_numerical_type<T1,T2,typename enable_if<and_
+  <typename is_floating_point<T1>::type, typename is_integral<T2>::type>
+  ::value>::type>
+  {
+  typedef T1 type;
+  };
+
+template<typename T>
+  struct is_empty_helper : public T
+  {
+  };
+
+struct is_empty_helper_base
+{
+};
+
+template<typename T>
+  struct is_empty : integral_constant<bool,
+    sizeof(is_empty_helper_base) == sizeof(is_empty_helper<T>)
+  >
+  {
+  };
+
+template <typename Invokable, typename... Args>
+using invoke_result_t =
+#if THRUST_CPP_DIALECT < 2017
+  typename ::cuda::std::result_of<Invokable(Args...)>::type;
+#else // 2017+
+  ::cuda::std::invoke_result_t<Invokable, Args...>;
+#endif
+
+template <class F, class... Us> 
+struct invoke_result
+{
+  using type = invoke_result_t<F, Us...>;
+};
+
+} // end detail
+
+using detail::integral_constant;
+using detail::true_type;
+using detail::false_type;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/type_traits/has_trivial_assign.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/function_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/function_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..1098201366efed74f7331d43454b2bd1675a948b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/function_traits.h
@@ -0,0 +1,97 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward definitions for is_commutative
+template <typename T> struct plus;
+template <typename T> struct multiplies;
+template <typename T> struct minimum;
+template <typename T> struct maximum;
+template <typename T> struct logical_or;
+template <typename T> struct logical_and;
+template <typename T> struct bit_or;
+template <typename T> struct bit_and;
+template <typename T> struct bit_xor;
+
+namespace detail
+{
+
+
+// some metafunctions which check for the nested types of the adaptable functions
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_result_type, result_type)
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_argument_type, argument_type)
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_first_argument_type, first_argument_type)
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_second_argument_type, second_argument_type)
+
+
+template<typename AdaptableBinaryFunction>
+  struct result_type
+{
+  typedef typename AdaptableBinaryFunction::result_type type;
+};
+
+
+template<typename T>
+  struct is_adaptable_unary_function
+    : thrust::detail::and_<
+        has_result_type<T>,
+        has_argument_type<T>
+      >
+{};
+
+
+template<typename T>
+  struct is_adaptable_binary_function
+    : thrust::detail::and_<
+        has_result_type<T>,
+        thrust::detail::and_<
+          has_first_argument_type<T>,
+          has_second_argument_type<T>
+        >
+      >
+{};
+
+
+template<typename BinaryFunction>
+  struct is_commutative
+    : public thrust::detail::false_type
+{};
+
+template<typename T> struct is_commutative< typename thrust::plus<T>        > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::multiplies<T>  > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::minimum<T>     > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::maximum<T>     > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::logical_or<T>  > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::logical_and<T> > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::bit_or<T>      > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::bit_and<T>     > : public thrust::detail::is_arithmetic<T> {};
+template<typename T> struct is_commutative< typename thrust::bit_xor<T>     > : public thrust::detail::is_arithmetic<T> {};
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_member_function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_member_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..c33fe28f654562dc064bcdf847a5da30d085de62
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_member_function.h
@@ -0,0 +1,38 @@
+/*
+ *  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/type_traits.h>
+
+#include <utility> // for std::declval
+
+#define __THRUST_DEFINE_HAS_MEMBER_FUNCTION(trait_name, member_function_name)  \
+  template <typename T, typename Signature, typename = void>                   \
+  struct trait_name : thrust::false_type                                       \
+  {};                                                                          \
+                                                                               \
+  template <typename T, typename ResultT, typename... Args>                    \
+  struct trait_name<T,                                                         \
+                    ResultT(Args...),                                          \
+                    typename thrust::detail::enable_if<                        \
+                      thrust::detail::is_same<ResultT, void>::value ||         \
+                      thrust::detail::is_convertible<                          \
+                        ResultT,                                               \
+                        decltype(std::declval<T>().member_function_name(       \
+                          std::declval<Args>()...))>::value>::type>            \
+      : thrust::true_type                                                      \
+  {};
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_nested_type.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_nested_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..78bb4b7f57a2f62d70ed6cf04bf58913b4100b69
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_nested_type.h
@@ -0,0 +1,32 @@
+/*
+ *  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/type_traits.h>
+
+#define __THRUST_DEFINE_HAS_NESTED_TYPE(trait_name, nested_type_name) \
+template<typename T> \
+  struct trait_name  \
+{                    \
+  typedef char yes_type; \
+  typedef int  no_type;  \
+  template<typename S> static yes_type test(typename S::nested_type_name *); \
+  template<typename S> static no_type  test(...); \
+  static bool const value = sizeof(test<T>(0)) == sizeof(yes_type);\
+  typedef thrust::detail::integral_constant<bool, value> type;\
+};
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_trivial_assign.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_trivial_assign.h
new file mode 100644
index 0000000000000000000000000000000000000000..7222ce593f5183d7c5f59d78fd00fc6adf02caf6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/has_trivial_assign.h
@@ -0,0 +1,47 @@
+/*
+ *  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 type_traits.h
+ *  \brief Temporarily define some type traits
+ *         until nvcc can compile tr1::type_traits.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+
+#include <cuda/std/type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename T> 
+struct has_trivial_assign
+  : public integral_constant<
+      bool, 
+      (is_pod<T>::value && !is_const<T>::value) 
+      || ::cuda::std::is_trivially_copy_assignable<T>::value
+    >
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_call_possible.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_call_possible.h
new file mode 100644
index 0000000000000000000000000000000000000000..58c1aca4df0fa91c7a60ca57a90a2ed9ab70c533
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_call_possible.h
@@ -0,0 +1,162 @@
+/*
+ *  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>
+
+#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 
+{
+  typedef dest_type type; 
+}; 
+
+template<typename src_type, typename dest_type> 
+struct clone_constness<const src_type, dest_type> 
+{ 
+  typedef const dest_type type; 
+};
+
+} // end is_call_possible_detail
+} // end 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;                                                                                                 \
+    };                                                                                                                                    \
+                                                                                                                                          \
+    typedef typename thrust::detail::is_call_possible_detail::clone_constness<T, derived>::type 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 typename add_reference<derived_type>::type test_me;                                                                          \
+      static typename add_reference<Arg>::type          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 typename add_reference<derived_type>::type test_me;                                                                          \
+      static typename add_reference<Arg1>::type         arg1;                                                                             \
+      static typename add_reference<Arg2>::type         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 typename add_reference<derived_type>::type test_me;                                                                          \
+      static typename add_reference<Arg1>::type         arg1;                                                                             \
+      static typename add_reference<Arg2>::type         arg2;                                                                             \
+      static typename add_reference<Arg3>::type         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 typename add_reference<derived_type>::type test_me;                                                                          \
+      static typename add_reference<Arg1>::type         arg1;                                                                             \
+      static typename add_reference<Arg2>::type         arg2;                                                                             \
+      static typename add_reference<Arg3>::type         arg3;                                                                             \
+      static typename add_reference<Arg4>::type         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;                                        \
+    typedef thrust::detail::integral_constant<bool,value> type;                                                                           \
+}; 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_metafunction_defined.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_metafunction_defined.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c7a4be52df6a6529704e938186fdf65d4568c99
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/is_metafunction_defined.h
@@ -0,0 +1,42 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(is_metafunction_defined, type)
+
+template<typename Metafunction>
+  struct enable_if_defined
+    : thrust::detail::lazy_enable_if<
+        is_metafunction_defined<Metafunction>::value,
+        Metafunction
+      >
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_discard_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_discard_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..210409d626908cb9228ef4e61910b03178ab0b49
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_discard_iterator.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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/discard_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename Iterator>
+struct is_discard_iterator
+  : public thrust::detail::false_type
+{};
+
+template <typename System>
+struct is_discard_iterator< thrust::discard_iterator<System> >
+ : public thrust::detail::true_type
+{};
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_output_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..555b67400cd68d00b14711410ad9ec2dde2b98c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/iterator/is_output_iterator.h
@@ -0,0 +1,65 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/detail/any_assign.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+
+template<typename T>
+  struct is_void_like
+    : thrust::detail::or_<
+        thrust::detail::is_void<T>,
+        thrust::detail::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
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/minimum_type.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/minimum_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..2417e327df8e300f3a60d1bf34619ae5c3c24f24
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/minimum_type.h
@@ -0,0 +1,163 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{ 
+
+namespace minimum_type_detail
+{
+
+//
+// Returns the minimum type or is empty
+// if T1 and T2 are unrelated.
+//
+template <typename T1, typename T2, bool GreaterEqual, bool LessEqual> struct minimum_type_impl {};
+  
+template <typename T1, typename T2>
+struct minimum_type_impl<T1,T2,true,false>
+{
+  typedef T2 type;
+}; // end minimum_type_impl
+
+template <typename T1, typename T2>
+struct minimum_type_impl<T1,T2,false,true>
+{
+  typedef T1 type;
+}; // end minimum_type_impl
+
+template <typename T1, typename T2>
+struct minimum_type_impl<T1,T2,true,true>
+{
+  typedef T1 type;
+}; // end minimum_type_impl
+
+template <typename T1, typename T2>
+struct primitive_minimum_type
+  : minimum_type_detail::minimum_type_impl<
+      T1,
+      T2,
+      THRUST_NS_QUALIFIER::detail::is_convertible<T1,T2>::value,
+      THRUST_NS_QUALIFIER::detail::is_convertible<T2,T1>::value
+    >
+{
+}; // end primitive_minimum_type
+
+// because some types are not convertible (even to themselves)
+// specialize primitive_minimum_type for when both types are identical
+template <typename T>
+struct primitive_minimum_type<T,T>
+{
+  typedef T type;
+}; // end primitive_minimum_type
+
+// XXX this belongs somewhere more general
+struct any_conversion
+{
+  template<typename T> operator T (void);
+};
+
+} // end minimum_type_detail
+
+template<typename T1,
+         typename T2  = minimum_type_detail::any_conversion,
+         typename T3  = minimum_type_detail::any_conversion,
+         typename T4  = minimum_type_detail::any_conversion,
+         typename T5  = minimum_type_detail::any_conversion,
+         typename T6  = minimum_type_detail::any_conversion,
+         typename T7  = minimum_type_detail::any_conversion,
+         typename T8  = minimum_type_detail::any_conversion,
+         typename T9  = minimum_type_detail::any_conversion,
+         typename T10 = minimum_type_detail::any_conversion,
+         typename T11 = minimum_type_detail::any_conversion,
+         typename T12 = minimum_type_detail::any_conversion,
+         typename T13 = minimum_type_detail::any_conversion,
+         typename T14 = minimum_type_detail::any_conversion,
+         typename T15 = minimum_type_detail::any_conversion,
+         typename T16 = minimum_type_detail::any_conversion>
+  struct minimum_type;
+
+// base case
+template<typename T1, typename T2>
+  struct minimum_type<T1,T2>
+    : minimum_type_detail::primitive_minimum_type<T1,T2>
+{};
+
+template<typename T1, typename T2>
+  struct lazy_minimum_type
+    : minimum_type<
+        typename T1::type,
+        typename T2::type
+      >
+{};
+
+// carefully avoid referring to a nested ::type which may not exist
+template<typename T1,  typename T2,  typename T3,  typename T4,
+         typename T5,  typename T6,  typename T7,  typename T8,
+         typename T9,  typename T10, typename T11, typename T12,
+         typename T13, typename T14, typename T15, typename T16>
+  struct minimum_type
+    : lazy_minimum_type<
+        lazy_minimum_type<
+          lazy_minimum_type<
+            minimum_type<
+              T1,T2
+            >,
+            minimum_type<
+              T3,T4
+            >
+          >,
+          lazy_minimum_type<
+            minimum_type<
+              T5,T6
+            >,
+            minimum_type<
+              T7,T8
+            >
+          >
+        >,
+        lazy_minimum_type<
+          lazy_minimum_type<
+            minimum_type<
+              T9,T10
+            >,
+            minimum_type<
+              T11,T12
+            >
+          >,
+          lazy_minimum_type<
+            minimum_type<
+              T13,T14
+            >,
+            minimum_type<
+              T15,T16
+            >
+          >
+        >
+      >
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/pointer_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/pointer_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..90a8bc29dec3a14f15fc47b0ce7f8638e1ab2a33
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/pointer_traits.h
@@ -0,0 +1,395 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/detail/type_traits/has_nested_type.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 Arg>
+  struct pointer_element<Ptr<Arg> >
+{
+  typedef Arg type;
+};
+
+template<template<typename,typename> class Ptr, typename Arg1, typename Arg2>
+  struct pointer_element<Ptr<Arg1,Arg2> >
+{
+  typedef Arg1 type;
+};
+
+template<template<typename,typename,typename> class Ptr, typename Arg1, typename Arg2, typename Arg3>
+  struct pointer_element<Ptr<Arg1,Arg2,Arg3> >
+{
+  typedef Arg1 type;
+};
+
+template<template<typename,typename,typename,typename> class Ptr, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  struct pointer_element<Ptr<Arg1,Arg2,Arg3,Arg4> >
+{
+  typedef Arg1 type;
+};
+
+template<template<typename,typename,typename,typename,typename> class Ptr, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+  struct pointer_element<Ptr<Arg1,Arg2,Arg3,Arg4,Arg5> >
+{
+  typedef Arg1 type;
+};
+
+template<typename T>
+  struct pointer_element<T*>
+{
+  typedef T type;
+};
+
+template<typename Ptr>
+  struct pointer_difference
+{
+  typedef typename Ptr::difference_type type;
+};
+
+template<typename T>
+  struct pointer_difference<T*>
+{
+  typedef std::ptrdiff_t type;
+};
+
+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...>>;
+};
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(has_raw_pointer, raw_pointer)
+
+namespace pointer_traits_detail
+{
+
+template<typename Ptr, typename Enable = void> struct pointer_raw_pointer_impl {};
+
+template<typename T>
+  struct pointer_raw_pointer_impl<T*>
+{
+  typedef T* type;
+};
+
+template<typename Ptr>
+  struct pointer_raw_pointer_impl<Ptr, typename enable_if<has_raw_pointer<Ptr>::value>::type>
+{
+  typedef typename Ptr::raw_pointer type;
+};
+
+} // end 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>
+  __host__ __device__
+  capture_address(T &r)
+    : m_addr(&r)
+  {}
+
+  inline __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<
+        thrust::detail::is_void<T>::value,
+        thrust::detail::identity_<capture_address<T> >,
+        thrust::detail::add_reference<T>
+      >
+{};
+
+}
+
+template<typename Ptr>
+  struct pointer_traits
+{
+  typedef Ptr                                    pointer;
+  typedef typename Ptr::reference                reference;
+  typedef typename pointer_element<Ptr>::type    element_type;
+  typedef typename pointer_difference<Ptr>::type difference_type;
+
+  template<typename U>
+    struct rebind
+  {
+    typedef typename rebind_pointer<Ptr,U>::type other;
+  };
+
+  __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
+  typedef typename pointer_raw_pointer<Ptr>::type raw_pointer;
+
+  __host__ __device__
+  inline static raw_pointer get(pointer ptr)
+  {
+    return ptr.get();
+  }
+};
+
+template<typename T>
+  struct pointer_traits<T*>
+{
+  typedef T*                                    pointer;
+  typedef T&                                    reference;
+  typedef T                                     element_type;
+  typedef typename pointer_difference<T*>::type difference_type;
+
+  template<typename U>
+    struct rebind
+  {
+    typedef U* other;
+  };
+
+  __host__ __device__
+  inline static pointer pointer_to(typename pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  typedef typename pointer_raw_pointer<T*>::type raw_pointer;
+
+  __host__ __device__
+  inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template<>
+  struct pointer_traits<void*>
+{
+  typedef void*                                    pointer;
+  typedef void                                     reference;
+  typedef void                                     element_type;
+  typedef pointer_difference<void*>::type          difference_type;
+
+  template<typename U>
+    struct rebind
+  {
+    typedef U* other;
+  };
+
+  __host__ __device__
+  inline static pointer pointer_to(pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  typedef pointer_raw_pointer<void*>::type raw_pointer;
+
+  __host__ __device__
+  inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template<>
+  struct pointer_traits<const void*>
+{
+  typedef const void*                           pointer;
+  typedef const void                            reference;
+  typedef const void                            element_type;
+  typedef pointer_difference<const void*>::type difference_type;
+
+  template<typename U>
+    struct rebind
+  {
+    typedef U* other;
+  };
+
+  __host__ __device__
+  inline static pointer pointer_to(pointer_traits_detail::pointer_to_param<element_type>::type r)
+  {
+    return &r;
+  }
+
+  // thrust additions follow
+  typedef pointer_raw_pointer<const void*>::type raw_pointer;
+
+  __host__ __device__
+  inline static raw_pointer get(pointer ptr)
+  {
+    return ptr;
+  }
+};
+
+template<typename FromPtr, typename ToPtr>
+  struct is_pointer_system_convertible
+    : thrust::detail::is_convertible<
+        typename iterator_system<FromPtr>::type,
+        typename iterator_system<ToPtr>::type
+      >
+{};
+
+template<typename FromPtr, typename ToPtr>
+  struct is_pointer_convertible
+    : thrust::detail::and_<
+        thrust::detail::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
+    : thrust::detail::and_<
+        thrust::detail::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
+    : thrust::detail::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
+    : thrust::detail::enable_if<
+        lazy_is_void_pointer_system_convertible<FromPtr,ToPtr>::type::value,
+        T
+      >
+{};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/result_of_adaptable_function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/result_of_adaptable_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..edf797f141bc0b1f6713fd463b5f300b2f299953
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/type_traits/result_of_adaptable_function.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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/function_traits.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+// Sets `type` to the result of the specified Signature invocation. If the
+// callable defines a `result_type` alias member, that type is used instead.
+// Use invoke_result / result_of when FuncType::result_type is not defined.
+template <typename Signature, typename Enable = void>
+struct result_of_adaptable_function
+{
+private:
+  template <typename Sig> struct impl;
+
+  template <typename F, typename... Args>
+  struct impl<F(Args...)>
+  {
+    using type = invoke_result_t<F, Args...>;
+  };
+
+public:
+  using type = typename impl<Signature>::type;
+};
+
+// specialization for invocations which define result_type
+template <typename Functor, typename... ArgTypes>
+struct result_of_adaptable_function<
+  Functor(ArgTypes...),
+  typename thrust::detail::enable_if<
+    thrust::detail::has_result_type<Functor>::value>::type>
+{
+  using type = typename Functor::result_type;
+};
+
+} // namespace detail
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_copy.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_copy.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2778693ad3cd1a7c05385393479577d4f161646e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_copy.inl
@@ -0,0 +1,95 @@
+/*
+ *  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>
+
+#include <thrust/uninitialized_copy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_copy.h>
+#include <thrust/system/detail/adl/uninitialized_copy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                     InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy;
+  return uninitialized_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result);
+} // end uninitialized_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::uninitialized_copy_n;
+  return uninitialized_copy_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, result);
+} // end uninitialized_copy_n()
+
+
+template<typename InputIterator,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy(InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy(select_system(system1,system2), first, last, result);
+} // end uninitialized_copy()
+
+
+template<typename InputIterator,
+         typename Size,
+         typename ForwardIterator>
+  ForwardIterator uninitialized_copy_n(InputIterator first,
+                                       Size n,
+                                       ForwardIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type   System1;
+  typedef typename thrust::iterator_system<ForwardIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::uninitialized_copy_n(select_system(system1,system2), first, n, result);
+} // end uninitialized_copy_n()
+
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_fill.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_fill.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e013dac7b078ebfc54d244a29aa1ba56a408462e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/uninitialized_fill.inl
@@ -0,0 +1,90 @@
+/*
+ *  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>
+
+#include <thrust/uninitialized_fill.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/uninitialized_fill.h>
+#include <thrust/system/detail/adl/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void uninitialized_fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill;
+  return uninitialized_fill(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, x);
+} // end uninitialized_fill()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename Size, typename T>
+__host__ __device__
+  ForwardIterator uninitialized_fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::uninitialized_fill_n;
+  return uninitialized_fill_n(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, n, x);
+} // end uninitialized_fill_n()
+
+
+template<typename ForwardIterator,
+         typename T>
+  void uninitialized_fill(ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  thrust::uninitialized_fill(select_system(system), first, last, x);
+} // end uninitialized_fill()
+
+
+template<typename ForwardIterator,
+         typename Size,
+         typename T>
+  ForwardIterator uninitialized_fill_n(ForwardIterator first,
+                                       Size n,
+                                       const T &x)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::uninitialized_fill_n(select_system(system), first, n, x);
+} // end uninitialized_fill_n()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/unique.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/unique.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ac5475f0238da598ccd20997c04e02b3bb4747b1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/unique.inl
@@ -0,0 +1,393 @@
+/*
+ *  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>
+#include <thrust/unique.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/unique.h>
+#include <thrust/system/detail/generic/unique_by_key.h>
+#include <thrust/system/detail/adl/unique.h>
+#include <thrust/system/detail/adl/unique_by_key.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique;
+  return unique(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator output,
+                           BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_copy;
+  return unique_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first,
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first,
+                BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key;
+  return unique_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1 keys_first,
+                     InputIterator1 keys_last,
+                     InputIterator2 values_first,
+                     OutputIterator1 keys_output,
+                     OutputIterator2 values_output,
+                     BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_by_key_copy;
+  return unique_by_key_copy(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+
+template<typename ForwardIterator>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last);
+} // end unique()
+
+
+template<typename ForwardIterator,
+         typename BinaryPredicate>
+  ForwardIterator unique(ForwardIterator first,
+                         ForwardIterator last,
+                         BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique(select_system(system), first, last, binary_pred);
+} // end unique()
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output);
+} // end unique_copy()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+  OutputIterator unique_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator output,
+                             BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_copy(select_system(system1,system2), first, last, output, binary_pred);
+} // end unique_copy()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first);
+} // end unique_by_key()
+
+
+template<typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(ForwardIterator1 keys_first,
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first,
+                  BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator1>::type System1;
+  typedef typename thrust::iterator_system<ForwardIterator2>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::unique_by_key(select_system(system1,system2), keys_first, keys_last, values_first, binary_pred);
+} // end unique_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output);
+} // end unique_by_key_copy()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(InputIterator1 keys_first,
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_output,
+                       OutputIterator2 values_output,
+                       BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::unique_by_key_copy(select_system(system1,system2,system3,system4), keys_first, keys_last, values_first, keys_output, values_output, binary_pred);
+} // end unique_by_key_copy()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy,
+          typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::unique_count;
+  return unique_count(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last, binary_pred);
+} // end unique_count()
+
+__thrust_exec_check_disable__
+template <typename ForwardIterator>
+__host__ __device__
+    typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::unique_count(select_system(system), first, last);
+} // end unique_count()
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/use_default.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/use_default.h
new file mode 100644
index 0000000000000000000000000000000000000000..f25b6274c4475db78807a520bfe72994b517f62c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/use_default.h
@@ -0,0 +1,26 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+struct use_default {};
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/util/align.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/util/align.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3aa75bfe411204115713a600863d447ebfafc1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/util/align.h
@@ -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>
+
+#include <thrust/detail/cstdint.h>
+
+// functions to handle memory alignment
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace util
+{
+
+
+template<typename T>
+__host__ __device__
+T *align_up(T * ptr, detail::uintptr_t bytes)
+{
+  return (T *) ( bytes * (((detail::uintptr_t) ptr + (bytes - 1)) / bytes) );
+}
+
+
+template<typename T>
+__host__ __device__
+T *align_down(T * ptr, detail::uintptr_t bytes)
+{
+  return (T *) ( bytes * (detail::uintptr_t(ptr) / bytes) );
+}
+
+
+template<typename T>
+__host__ __device__
+bool is_aligned(T * ptr, detail::uintptr_t bytes = sizeof(T))
+{
+  return detail::uintptr_t(ptr) % bytes == 0;
+}
+
+
+} // end namespace util
+} // end namespace detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c4da449eab7621aa038e8e1016b382590d092b7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.h
@@ -0,0 +1,627 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file vector_base.h
+ *  \brief Defines the interface to a base class for
+ *         host_vector & device_vector.
+ */
+
+#pragma once
+
+#include <thrust/iterator/detail/normal_iterator.h>
+#include <thrust/iterator/reverse_iterator.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/config.h>
+#include <thrust/detail/contiguous_storage.h>
+
+#include <initializer_list>
+#include <vector>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename T, typename Alloc>
+  class vector_base
+{
+  private:
+    typedef thrust::detail::contiguous_storage<T,Alloc> storage_type;
+
+  public:
+    // typedefs
+    typedef typename storage_type::value_type      value_type;
+    typedef typename storage_type::pointer         pointer;
+    typedef typename storage_type::const_pointer   const_pointer;
+    typedef typename storage_type::reference       reference;
+    typedef typename storage_type::const_reference const_reference;
+    typedef typename storage_type::size_type       size_type;
+    typedef typename storage_type::difference_type difference_type;
+    typedef typename storage_type::allocator_type  allocator_type;
+
+    typedef typename storage_type::iterator        iterator;
+    typedef typename storage_type::const_iterator  const_iterator;
+
+    typedef thrust::reverse_iterator<iterator>       reverse_iterator;
+    typedef thrust::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    /*! This constructor creates an empty vector_base.
+     */
+    vector_base(void);
+
+    /*! This constructor creates an empty vector_base.
+     *  \param alloc The allocator to use by this vector_base.
+     */
+    explicit vector_base(const Alloc &alloc);
+
+    /*! This constructor creates a vector_base with default-constructed
+     *  elements.
+     *  \param n The number of elements to create.
+     */
+    explicit vector_base(size_type n);
+
+    /*! This constructor creates a vector_base with default-constructed
+     *  elements.
+     *  \param n The number of elements to create.
+     *  \param alloc The allocator to use by this vector_base.
+     */
+    explicit vector_base(size_type n, const Alloc &alloc);
+
+    /*! This constructor creates a vector_base with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     */
+    explicit vector_base(size_type n, const value_type &value);
+
+    /*! This constructor creates a vector_base with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     *  \param alloc The allocator to use by this vector_base.
+     */
+    explicit vector_base(size_type n, const value_type &value, const Alloc &alloc);
+
+    /*! Copy constructor copies from an exemplar vector_base.
+     *  \param v The vector_base to copy.
+     */
+    vector_base(const vector_base &v);
+
+    /*! Copy constructor copies from an exemplar vector_base.
+     *  \param v The vector_base to copy.
+     *  \param alloc The allocator to use by this vector_base.
+     */
+    vector_base(const vector_base &v, const Alloc &alloc);
+
+  #if THRUST_CPP_DIALECT >= 2011
+    /*! Move constructor moves from another vector_base.
+     *  \param v The vector_base to move.
+     */
+    vector_base(vector_base &&v);
+
+    // FIXME: the internal Thrust machinery in range_init doesn't work with move
+    // iterators, which is necessary for the following constructor to be implemented
+    // correctly
+    // vector_base(vector_base &&v, const Alloc &alloc);
+  #endif
+
+    /*! Copy assign operator copies from another vector_base.
+     *  \param v The vector_base to copy.
+     */
+    vector_base &operator=(const vector_base &v);
+
+    /*! Move assign operator moves from another vector_base.
+     *  \param v The vector_base to move.
+     */
+    vector_base &operator=(vector_base &&v);
+
+    /*! This constructor builds a \p vector_base from an intializer_list.
+     *  \param il The intializer_list.
+     */
+    vector_base(std::initializer_list<T> il);
+      
+    /*! This constructor builds a \p vector_base from an intializer_list.
+     *  \param il The intializer_list.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    vector_base(std::initializer_list<T> il, const Alloc &alloc);
+    
+    /*! Assign operator copies from an initializer_list
+     *  \param il The initializer_list.
+     */
+    vector_base &operator=(std::initializer_list<T> il);
+
+    /*! Copy constructor copies from an exemplar vector_base with different
+     *  type.
+     *  \param v The vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    vector_base(const vector_base<OtherT, OtherAlloc> &v);
+
+    /*! assign operator makes a copy of an exemplar vector_base with different
+     *  type.
+     *  \param v The vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    vector_base &operator=(const vector_base<OtherT,OtherAlloc> &v);
+
+    /*! Copy constructor copies from an exemplar std::vector.
+     *  \param v The std::vector to copy.
+     *  XXX TODO: Make this method redundant with a properly templatized constructor.
+     *            We would like to copy from a vector whose element type is anything
+     *            assignable to value_type.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    vector_base(const std::vector<OtherT, OtherAlloc> &v);
+
+    /*! assign operator makes a copy of an exemplar std::vector.
+     *  \param v The vector to copy.
+     *  XXX TODO: Templatize this assign on the type of the vector to copy from.
+     *            We would like to copy from a vector whose element type is anything
+     *            assignable to value_type.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    vector_base &operator=(const std::vector<OtherT,OtherAlloc> &v);
+
+    /*! This constructor builds a vector_base from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     */
+    template<typename InputIterator>
+    vector_base(InputIterator first, InputIterator last);
+
+    /*! This constructor builds a vector_base from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     *  \param alloc The allocator to use by this vector_base.
+     */
+    template<typename InputIterator>
+    vector_base(InputIterator first, InputIterator last, const Alloc &alloc);
+
+    /*! The destructor erases the elements.
+     */
+    ~vector_base(void);
+
+    /*! \brief Resizes this vector_base to the specified number of elements.
+     *  \param new_size Number of elements this vector_base should contain.
+     *  \throw std::length_error If n exceeds max_size9).
+     *
+     *  This method will resize this vector_base to the specified number of
+     *  elements. If the number is smaller than this vector_base's current
+     *  size this vector_base is truncated, otherwise this vector_base is
+     *  extended and new elements are default constructed.
+     */
+    void resize(size_type new_size);
+
+    /*! \brief Resizes this vector_base to the specified number of elements.
+     *  \param new_size Number of elements this vector_base should contain.
+     *  \param x Data with which new elements should be populated.
+     *  \throw std::length_error If n exceeds max_size().
+     *
+     *  This method will resize this vector_base to the specified number of
+     *  elements.  If the number is smaller than this vector_base's current
+     *  size this vector_base is truncated, otherwise this vector_base is
+     *  extended and new elements are populated with given data.
+     */
+    void resize(size_type new_size, const value_type &x);
+
+    /*! Returns the number of elements in this vector_base.
+     */
+    __host__ __device__
+    size_type size(void) const;
+
+    /*! Returns the size() of the largest possible vector_base.
+     *  \return The largest possible return value of size().
+     */
+    __host__ __device__
+    size_type max_size(void) const;
+
+    /*! \brief If n is less than or equal to capacity(), this call has no effect.
+     *         Otherwise, this method is a request for allocation of additional memory. If
+     *         the request is successful, then capacity() is greater than or equal to
+     *         n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+     *  \throw std::length_error If n exceeds max_size().
+     */
+    void reserve(size_type n);
+
+    /*! Returns the number of elements which have been reserved in this
+     *  vector_base.
+     */
+    __host__ __device__
+    size_type capacity(void) const;
+
+    /*! This method shrinks the capacity of this vector_base to exactly
+     *  fit its elements.
+     */
+    void shrink_to_fit(void);
+
+    /*! \brief Subscript access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read/write reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    __host__ __device__
+    reference operator[](size_type n);
+
+    /*! \brief Subscript read access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    __host__ __device__
+    const_reference operator[](size_type n) const;
+
+    /*! This method returns an iterator pointing to the beginning of
+     *  this vector_base.
+     *  \return mStart
+     */
+    __host__ __device__
+    iterator begin(void);
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector_base.
+     *  \return mStart
+     */
+    __host__ __device__
+    const_iterator begin(void) const;
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector_base.
+     *  \return mStart
+     */
+    __host__ __device__
+    const_iterator cbegin(void) const;
+
+    /*! This method returns a reverse_iterator pointing to the beginning of
+     *  this vector_base's reversed sequence.
+     *  \return A reverse_iterator pointing to the beginning of this
+     *          vector_base's reversed sequence.
+     */
+    __host__ __device__
+    reverse_iterator rbegin(void);
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector_base's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector_base's reversed sequence.
+     */
+    __host__ __device__
+    const_reverse_iterator rbegin(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector_base's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector_base's reversed sequence.
+     */
+    __host__ __device__
+    const_reverse_iterator crbegin(void) const;
+
+    /*! This method returns an iterator pointing to one element past the
+     *  last of this vector_base.
+     *  \return begin() + size().
+     */
+    __host__ __device__
+    iterator end(void);
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector_base.
+     *  \return begin() + size().
+     */
+    __host__ __device__
+    const_iterator end(void) const;
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector_base.
+     *  \return begin() + size().
+     */
+    __host__ __device__
+    const_iterator cend(void) const;
+
+    /*! This method returns a reverse_iterator pointing to one element past the
+     *  last of this vector_base's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    __host__ __device__
+    reverse_iterator rend(void);
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector_base's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    __host__ __device__
+    const_reverse_iterator rend(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector_base's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    __host__ __device__
+    const_reverse_iterator crend(void) const;
+
+    /*! This method returns a const_reference referring to the first element of this
+     *  vector_base.
+     *  \return The first element of this vector_base.
+     */
+    __host__ __device__
+    const_reference front(void) const;
+
+    /*! This method returns a reference pointing to the first element of this
+     *  vector_base.
+     *  \return The first element of this vector_base.
+     */
+    __host__ __device__
+    reference front(void);
+
+    /*! This method returns a const reference pointing to the last element of
+     *  this vector_base.
+     *  \return The last element of this vector_base.
+     */
+    __host__ __device__
+    const_reference back(void) const;
+
+    /*! This method returns a reference referring to the last element of
+     *  this vector_dev.
+     *  \return The last element of this vector_base.
+     */
+    __host__ __device__
+    reference back(void);
+
+    /*! This method returns a pointer to this vector_base's first element.
+     *  \return A pointer to the first element of this vector_base.
+     */
+    __host__ __device__
+    pointer data(void);
+
+    /*! This method returns a const_pointer to this vector_base's first element.
+     *  \return a const_pointer to the first element of this vector_base.
+     */
+    __host__ __device__
+    const_pointer data(void) const;
+
+    /*! This method resizes this vector_base to 0.
+     */
+    void clear(void);
+
+    /*! This method returns true iff size() == 0.
+     *  \return true if size() == 0; false, otherwise.
+     */
+    __host__ __device__
+    bool empty(void) const;
+
+    /*! This method appends the given element to the end of this vector_base.
+     *  \param x The element to append.
+     */
+    void push_back(const value_type &x);
+
+    /*! This method erases the last element of this vector_base, invalidating
+     *  all iterators and references to it.
+     */
+    void pop_back(void);
+
+    /*! This method swaps the contents of this vector_base with another vector_base.
+     *  \param v The vector_base with which to swap.
+     */
+    void swap(vector_base &v);
+
+    /*! This method removes the element at position pos.
+     *  \param pos The position of the element of interest.
+     *  \return An iterator pointing to the new location of the element that followed the element
+     *          at position pos.
+     */
+    iterator erase(iterator pos);
+
+    /*! This method removes the range of elements [first,last) from this vector_base.
+     *  \param first The beginning of the range of elements to remove.
+     *  \param last The end of the range of elements to remove.
+     *  \return An iterator pointing to the new location of the element that followed the last
+     *          element in the sequence [first,last).
+     */
+    iterator erase(iterator first, iterator last);
+
+    /*! This method inserts a single copy of a given exemplar value at the
+     *  specified position in this vector_base.
+     *  \param position The insertion position.
+     *  \param x The exemplar element to copy & insert.
+     *  \return An iterator pointing to the newly inserted element.
+     */
+    iterator insert(iterator position, const T &x); 
+
+    /*! This method inserts a copy of an exemplar value to a range at the
+     *  specified position in this vector_base.
+     *  \param position The insertion position
+     *  \param n The number of insertions to perform.
+     *  \param x The value to replicate and insert.
+     */
+    void insert(iterator position, size_type n, const T &x);
+
+    /*! This method inserts a copy of an input range at the specified position
+     *  in this vector_base.
+     *  \param position The insertion position.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator>Input Iterator</a>,
+     *                        and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>.
+     */
+    template<typename InputIterator>
+    void insert(iterator position, InputIterator first, InputIterator last);
+
+    /*! This version of \p assign replicates a given exemplar
+     *  \p n times into this vector_base.
+     *  \param n The number of times to copy \p x.
+     *  \param x The exemplar element to replicate.
+     */
+    void assign(size_type n, const T &x);
+
+    /*! This version of \p assign makes this vector_base a copy of a given input range.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>.
+     */
+    template<typename InputIterator>
+    void assign(InputIterator first, InputIterator last);
+
+    /*! This method returns a copy of this vector's allocator.
+     *  \return A copy of the alloctor used by this vector.
+     */
+    allocator_type get_allocator(void) const;
+
+  protected:
+    // Our storage
+    storage_type m_storage;
+
+    // The size of this vector_base, in number of elements.
+    size_type m_size;
+
+  private:
+    // these methods resolve the ambiguity of the constructor template of form (Iterator, Iterator)
+    template<typename IteratorOrIntegralType>
+      void init_dispatch(IteratorOrIntegralType begin, IteratorOrIntegralType end, false_type); 
+
+    template<typename IteratorOrIntegralType>
+      void init_dispatch(IteratorOrIntegralType n, IteratorOrIntegralType value, true_type); 
+
+    template<typename InputIterator>
+      void range_init(InputIterator first, InputIterator last);
+
+    template<typename InputIterator>
+      void range_init(InputIterator first, InputIterator last, thrust::incrementable_traversal_tag);
+
+    template<typename ForwardIterator>
+      void range_init(ForwardIterator first, ForwardIterator last, thrust::random_access_traversal_tag);
+
+    void default_init(size_type n);
+
+    void fill_init(size_type n, const T &x);
+
+    // these methods resolve the ambiguity of the insert() template of form (iterator, InputIterator, InputIterator)
+    template<typename InputIteratorOrIntegralType>
+      void insert_dispatch(iterator position, InputIteratorOrIntegralType first, InputIteratorOrIntegralType last, false_type);
+
+    // these methods resolve the ambiguity of the insert() template of form (iterator, InputIterator, InputIterator)
+    template<typename InputIteratorOrIntegralType>
+      void insert_dispatch(iterator position, InputIteratorOrIntegralType n, InputIteratorOrIntegralType x, true_type);
+
+    // this method appends n default-constructed elements at the end
+    void append(size_type n);
+
+    // this method performs insertion from a fill value
+    void fill_insert(iterator position, size_type n, const T &x);
+
+    // this method performs insertion from a range
+    template<typename InputIterator>
+      void copy_insert(iterator position, InputIterator first, InputIterator last);
+
+    // these methods resolve the ambiguity of the assign() template of form (InputIterator, InputIterator)
+    template<typename InputIterator>
+      void assign_dispatch(InputIterator first, InputIterator last, false_type);
+
+    // these methods resolve the ambiguity of the assign() template of form (InputIterator, InputIterator)
+    template<typename Integral>
+      void assign_dispatch(Integral n, Integral x, true_type);
+
+    // this method performs assignment from a range
+    template<typename InputIterator>
+      void range_assign(InputIterator first, InputIterator last);
+
+    // this method performs assignment from a range of RandomAccessIterators
+    template<typename RandomAccessIterator>
+      void range_assign(RandomAccessIterator first, RandomAccessIterator last, thrust::random_access_traversal_tag);
+
+    // this method performs assignment from a range of InputIterators
+    template<typename InputIterator>
+      void range_assign(InputIterator first, InputIterator last, thrust::incrementable_traversal_tag);
+
+    // this method performs assignment from a fill value
+    void fill_assign(size_type n, const T &x);
+
+    // this method allocates new storage and construct copies the given range
+    template<typename ForwardIterator>
+    void allocate_and_copy(size_type requested_size,
+                           ForwardIterator first, ForwardIterator last,
+                           storage_type &new_storage);
+}; // end vector_base
+
+} // end detail
+
+/*! This function assigns the contents of vector a to vector b and the
+ *  contents of vector b to vector a.
+ *
+ *  \param a The first vector of interest. After completion, the contents
+ *           of b will be returned here.
+ *  \param b The second vector of interest. After completion, the contents
+ *           of a will be returned here.
+ */
+template<typename T, typename Alloc>
+  void swap(detail::vector_base<T,Alloc> &a,
+            detail::vector_base<T,Alloc> &b);
+
+
+/*! This operator allows comparison between two vectors.
+ *  \param lhs The first \p vector to compare.
+ *  \param rhs The second \p vector to compare.
+ *  \return \c true if and only if each corresponding element in either
+ *          \p vector equals the other; \c false, otherwise.
+ */
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const detail::vector_base<T1,Alloc1>& lhs,
+                const detail::vector_base<T2,Alloc2>& rhs);
+    
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const detail::vector_base<T1,Alloc1>& lhs,
+                const std::vector<T2,Alloc2>&         rhs);
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const std::vector<T1,Alloc1>&         lhs,
+                const detail::vector_base<T2,Alloc2>& rhs);
+
+/*! This operator allows comparison between two vectors.
+ *  \param lhs The first \p vector to compare.
+ *  \param rhs The second \p vector to compare.
+ *  \return \c false if and only if each corresponding element in either
+ *          \p vector equals the other; \c true, otherwise.
+ */
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const detail::vector_base<T1,Alloc1>& lhs,
+                const detail::vector_base<T2,Alloc2>& rhs);
+    
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const detail::vector_base<T1,Alloc1>& lhs,
+                const std::vector<T2,Alloc2>&         rhs);
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const std::vector<T1,Alloc1>&         lhs,
+                const detail::vector_base<T2,Alloc2>& rhs);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/vector_base.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.inl
new file mode 100644
index 0000000000000000000000000000000000000000..bdd6c1c7ac1dfcf8961e7735e13bd2217de1ae14
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/detail/vector_base.inl
@@ -0,0 +1,1369 @@
+/*
+ *  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>
+#include <thrust/detail/vector_base.h>
+#include <thrust/detail/copy.h>
+#include <thrust/detail/overlapped_copy.h>
+#include <thrust/equal.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/temporary_array.h>
+
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(void)
+      :m_storage(),
+       m_size(0)
+{
+  ;
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(const Alloc &alloc)
+      :m_storage(alloc),
+       m_size(0)
+{
+  ;
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(size_type n)
+      :m_storage(),
+       m_size(0)
+{
+  default_init(n);
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(size_type n, const Alloc &alloc)
+      :m_storage(alloc),
+       m_size(0)
+{
+  default_init(n);
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(size_type n, const value_type &value)
+      :m_storage(),
+       m_size(0)
+{
+  fill_init(n,value);
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(size_type n, const value_type &value, const Alloc &alloc)
+      :m_storage(alloc),
+       m_size(0)
+{
+  fill_init(n,value);
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(const vector_base &v)
+      :m_storage(copy_allocator_t(), v.m_storage),
+       m_size(0)
+{
+  range_init(v.begin(), v.end());
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(const vector_base &v, const Alloc &alloc)
+      :m_storage(alloc),
+       m_size(0)
+{
+  range_init(v.begin(), v.end());
+} // end vector_base::vector_base()
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Alloc>
+    vector_base<T,Alloc>
+      ::vector_base(vector_base &&v)
+        :m_storage(copy_allocator_t(), v.m_storage),
+         m_size(0)
+  {
+    *this = std::move(v);
+  } //end vector_base::vector_base()
+#endif
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc> &
+    vector_base<T,Alloc>
+      ::operator=(const vector_base &v)
+{
+  if(this != &v)
+  {
+    m_storage.destroy_on_allocator_mismatch(v.m_storage, begin(), end());
+    m_storage.deallocate_on_allocator_mismatch(v.m_storage);
+
+    m_storage.propagate_allocator(v.m_storage);
+
+    assign(v.begin(), v.end());
+  } // end if
+
+  return *this;
+} // end vector_base::operator=()
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Alloc>
+    vector_base<T,Alloc> &
+      vector_base<T,Alloc>
+        ::operator=(vector_base &&v)
+  {
+    m_storage.destroy(begin(), end());
+    m_storage = std::move(v.m_storage);
+    m_size = std::move(v.m_size);
+
+    v.m_storage = contiguous_storage<T,Alloc>(copy_allocator_t(), m_storage);
+    v.m_size = 0;
+
+    return *this;
+  } // end vector_base::operator=()
+#endif
+
+template<typename T, typename Alloc>
+  template<typename OtherT, typename OtherAlloc>
+    vector_base<T,Alloc>
+      ::vector_base(const vector_base<OtherT,OtherAlloc> &v)
+        :m_storage(),
+         m_size(0)
+{
+  range_init(v.begin(), v.end());
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  template<typename OtherT, typename OtherAlloc>
+    vector_base<T,Alloc> &
+      vector_base<T,Alloc>
+        ::operator=(const vector_base<OtherT,OtherAlloc> &v)
+{
+  assign(v.begin(), v.end());
+
+  return *this;
+} // end vector_base::operator=()
+
+template<typename T, typename Alloc>
+  template<typename OtherT, typename OtherAlloc>
+    vector_base<T,Alloc>
+      ::vector_base(const std::vector<OtherT,OtherAlloc> &v)
+        :m_storage(),
+         m_size(0)
+{
+  range_init(v.begin(), v.end());
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  template<typename OtherT, typename OtherAlloc>
+    vector_base<T,Alloc> &
+      vector_base<T,Alloc>
+        ::operator=(const std::vector<OtherT,OtherAlloc> &v)
+{
+  assign(v.begin(), v.end());
+
+  return *this;
+} // end vector_base::operator=()
+
+  template<typename T, typename Alloc>
+    vector_base<T,Alloc>
+      ::vector_base(std::initializer_list<T> il)
+        :m_storage(),
+         m_size(0)
+  {
+    range_init(il.begin(), il.end());
+  } // end vector_base::vector_base()
+
+  template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::vector_base(std::initializer_list<T> il, const Alloc &alloc)
+    :m_storage(alloc),
+      m_size(0)
+  {
+    range_init(il.begin(), il.end());
+  } // end vector_base::vector_base()
+
+  template<typename T, typename Alloc>
+    vector_base<T,Alloc> &
+      vector_base<T,Alloc>
+      ::operator=(std::initializer_list<T> il)
+  {
+    assign(il.begin(), il.end());
+
+    return *this;
+  } // end vector_base::operator=()
+
+template<typename T, typename Alloc>
+  template<typename IteratorOrIntegralType>
+    void vector_base<T,Alloc>
+      ::init_dispatch(IteratorOrIntegralType n,
+                      IteratorOrIntegralType value,
+                      true_type)
+{
+  fill_init(n,value);
+} // end vector_base::init_dispatch()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::default_init(size_type n)
+{
+  if(n > 0)
+  {
+    m_storage.allocate(n);
+    m_size = n;
+
+    m_storage.default_construct_n(begin(), size());
+  } // end if
+} // end vector_base::default_init()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::fill_init(size_type n, const T &x)
+{
+  if(n > 0)
+  {
+    m_storage.allocate(n);
+    m_size = n;
+
+    m_storage.uninitialized_fill_n(begin(), size(), x);
+  } // end if
+} // end vector_base::fill_init()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::init_dispatch(InputIterator first,
+                      InputIterator last,
+                      false_type)
+{
+  range_init(first, last);
+} // end vector_base::init_dispatch()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::range_init(InputIterator first,
+                   InputIterator last)
+{
+  range_init(first, last,
+    typename thrust::iterator_traversal<InputIterator>::type());
+} // end vector_base::range_init()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::range_init(InputIterator first,
+                   InputIterator last,
+                   thrust::incrementable_traversal_tag)
+{
+  for(; first != last; ++first)
+    push_back(*first);
+} // end vector_base::range_init()
+
+template<typename T, typename Alloc>
+  template<typename ForwardIterator>
+    void vector_base<T,Alloc>
+      ::range_init(ForwardIterator first,
+                   ForwardIterator last,
+                   thrust::random_access_traversal_tag)
+{
+  size_type new_size = thrust::distance(first, last);
+
+  allocate_and_copy(new_size, first, last, m_storage);
+  m_size    = new_size;
+} // end vector_base::range_init()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    vector_base<T,Alloc>
+      ::vector_base(InputIterator first,
+                    InputIterator last)
+        :m_storage(),
+         m_size(0)
+{
+  // check the type of InputIterator: if it's an integral type,
+  // we need to interpret this call as (size_type, value_type)
+  typedef thrust::detail::is_integral<InputIterator> Integer;
+
+  init_dispatch(first, last, Integer());
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    vector_base<T,Alloc>
+      ::vector_base(InputIterator first,
+                    InputIterator last,
+                    const Alloc &alloc)
+        :m_storage(alloc),
+         m_size(0)
+{
+  // check the type of InputIterator: if it's an integral type,
+  // we need to interpret this call as (size_type, value_type)
+  typedef thrust::detail::is_integral<InputIterator> Integer;
+
+  init_dispatch(first, last, Integer());
+} // end vector_base::vector_base()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::resize(size_type new_size)
+{
+  if(new_size < size())
+  {
+    iterator new_end = begin();
+    thrust::advance(new_end, new_size);
+    erase(new_end, end());
+  } // end if
+  else
+  {
+    append(new_size - size());
+  } // end else
+} // end vector_base::resize()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::resize(size_type new_size, const value_type &x)
+{
+  if(new_size < size())
+  {
+    iterator new_end = begin();
+    thrust::advance(new_end, new_size);
+    erase(new_end, end());
+  } // end if
+  else
+  {
+    insert(end(), new_size - size(), x);
+  } // end else
+} // end vector_base::resize()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::size_type
+    vector_base<T,Alloc>
+      ::size(void) const
+{
+  return m_size;
+} // end vector_base::size()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::size_type
+    vector_base<T,Alloc>
+      ::max_size(void) const
+{
+  return m_storage.max_size();
+} // end vector_base::max_size()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::reserve(size_type n)
+{
+  if(n > capacity())
+  {
+    // compute the new capacity after the allocation
+    size_type new_capacity = n;
+
+    // do not exceed maximum storage
+    new_capacity = thrust::min THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, max_size());
+
+    // create new storage
+    storage_type new_storage(copy_allocator_t(), m_storage, new_capacity);
+
+    // record how many constructors we invoke in the try block below
+    iterator new_end = new_storage.begin();
+
+    try
+    {
+      // construct copy all elements into the newly allocated storage
+      new_end = m_storage.uninitialized_copy(begin(), end(), new_storage.begin());
+    } // end try
+    catch(...)
+    {
+      // something went wrong, so destroy & deallocate the new storage
+      new_storage.destroy(new_storage.begin(), new_end);
+      new_storage.deallocate();
+
+      // rethrow
+      throw;
+    } // end catch
+
+    // call destructors on the elements in the old storage
+    m_storage.destroy(begin(), end());
+
+    // record the vector's new state
+    m_storage.swap(new_storage);
+  } // end if
+} // end vector_base::reserve()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::size_type
+    vector_base<T,Alloc>
+      ::capacity(void) const
+{
+  return m_storage.size();
+} // end vector_base::capacity()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::shrink_to_fit(void)
+{
+  // use the swap trick
+  vector_base(*this).swap(*this);
+} // end vector_base::shrink_to_fit()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::reference
+    vector_base<T,Alloc>
+      ::operator[](const size_type n)
+{
+  return m_storage[n];
+} // end vector_base::operator[]
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reference
+    vector_base<T,Alloc>
+      ::operator[](const size_type n) const
+{
+  return m_storage[n];
+} // end vector_base::operator[]
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::iterator
+    vector_base<T,Alloc>
+      ::begin(void)
+{
+  return m_storage.begin();
+} // end vector_base::begin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_iterator
+    vector_base<T,Alloc>
+      ::begin(void) const
+{
+  return m_storage.begin();
+} // end vector_base::begin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_iterator
+    vector_base<T,Alloc>
+      ::cbegin(void) const
+{
+  return begin();
+} // end vector_base::cbegin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::reverse_iterator
+    vector_base<T,Alloc>
+      ::rbegin(void)
+{
+  return reverse_iterator(end());
+} // end vector_base::rbegin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reverse_iterator
+    vector_base<T,Alloc>
+      ::rbegin(void) const
+{
+  return const_reverse_iterator(end());
+} // end vector_base::rbegin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reverse_iterator
+    vector_base<T,Alloc>
+      ::crbegin(void) const
+{
+  return rbegin();
+} // end vector_base::crbegin()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::iterator
+    vector_base<T,Alloc>
+      ::end(void)
+{
+  iterator result = begin();
+  thrust::advance(result, size());
+  return result;
+} // end vector_base::end()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_iterator
+    vector_base<T,Alloc>
+      ::end(void) const
+{
+  const_iterator result = begin();
+  thrust::advance(result, size());
+  return result;
+} // end vector_base::end()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_iterator
+    vector_base<T,Alloc>
+      ::cend(void) const
+{
+  return end();
+} // end vector_base::cend()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::reverse_iterator
+    vector_base<T,Alloc>
+      ::rend(void)
+{
+  return reverse_iterator(begin());
+} // end vector_base::rend()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reverse_iterator
+    vector_base<T,Alloc>
+      ::rend(void) const
+{
+  return const_reverse_iterator(begin());
+} // end vector_base::rend()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reverse_iterator
+    vector_base<T,Alloc>
+      ::crend(void) const
+{
+  return rend();
+} // end vector_base::crend()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reference
+    vector_base<T,Alloc>
+      ::front(void) const
+{
+  return *begin();
+} // end vector_base::front()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::reference
+    vector_base<T,Alloc>
+      ::front(void)
+{
+  return *begin();
+} // end vector_base::front()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_reference
+    vector_base<T,Alloc>
+      ::back(void) const
+{
+  const_iterator ptr_to_back = end();
+  --ptr_to_back;
+  return *ptr_to_back;
+} // end vector_base::vector_base
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::reference
+    vector_base<T,Alloc>
+      ::back(void)
+{
+  iterator ptr_to_back = end();
+  --ptr_to_back;
+  return *ptr_to_back;
+} // end vector_base::vector_base
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::pointer
+    vector_base<T,Alloc>
+      ::data(void)
+{
+  return pointer(&front());
+} // end vector_base::data()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  typename vector_base<T,Alloc>::const_pointer
+    vector_base<T,Alloc>
+      ::data(void) const
+{
+  return const_pointer(&front());
+} // end vector_base::data()
+
+template<typename T, typename Alloc>
+  vector_base<T,Alloc>
+    ::~vector_base(void)
+{
+  // destroy every living thing
+  if (!empty())
+    m_storage.destroy(begin(),end());
+} // end vector_base::~vector_base()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::clear(void)
+{
+  erase(begin(), end());
+} // end vector_base::~vector_dev()
+
+template<typename T, typename Alloc>
+  __host__ __device__
+  bool vector_base<T,Alloc>
+    ::empty(void) const
+{
+  return size() == 0;
+} // end vector_base::empty();
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::push_back(const value_type &x)
+{
+  insert(end(), x);
+} // end vector_base::push_back()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::pop_back(void)
+{
+  iterator e = end();
+  iterator ptr_to_back = e;
+  --ptr_to_back;
+  m_storage.destroy(ptr_to_back, e);
+  --m_size;
+} // end vector_base::pop_back()
+
+template<typename T, typename Alloc>
+  typename vector_base<T,Alloc>::iterator vector_base<T,Alloc>
+    ::erase(iterator pos)
+{
+  iterator end = pos;
+  ++end;
+  return erase(pos,end);
+} // end vector_base::erase()
+
+template<typename T, typename Alloc>
+  typename vector_base<T,Alloc>::iterator vector_base<T,Alloc>
+    ::erase(iterator first, iterator last)
+{
+  // overlap copy the range [last,end()) to first
+  // XXX this copy only potentially overlaps
+  iterator i = thrust::detail::overlapped_copy(last, end(), first);
+
+  // destroy everything after i
+  m_storage.destroy(i, end());
+
+  // modify our size
+  m_size -= (last - first);
+
+  // return an iterator pointing to the position of the first element
+  // following the erased range
+  return first;
+} // end vector_base::erase()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::swap(vector_base &v)
+{
+  thrust::swap(m_storage,  v.m_storage);
+  thrust::swap(m_size,     v.m_size);
+} // end vector_base::swap()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::assign(size_type n, const T &x)
+{
+  fill_assign(n, x);
+} // end vector_base::assign()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::assign(InputIterator first, InputIterator last)
+{
+  // we could have received assign(n, x), so disambiguate on the
+  // type of InputIterator
+  typedef typename thrust::detail::is_integral<InputIterator> integral;
+
+  assign_dispatch(first, last, integral());
+} // end vector_base::assign()
+
+template<typename T, typename Alloc>
+  typename vector_base<T,Alloc>::allocator_type
+    vector_base<T,Alloc>
+      ::get_allocator(void) const
+{
+  return m_storage.get_allocator();
+} // end vector_base::get_allocator()
+
+template<typename T, typename Alloc>
+  typename vector_base<T,Alloc>::iterator
+    vector_base<T,Alloc>
+      ::insert(iterator position, const T &x)
+{
+  // find the index of the insertion
+  size_type index = thrust::distance(begin(), position);
+
+  // make the insertion
+  insert(position, 1, x);
+
+  // return an iterator pointing back to position
+  iterator result = begin();
+  thrust::advance(result, index);
+  return result;
+} // end vector_base::insert()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::insert(iterator position, size_type n, const T &x)
+{
+  fill_insert(position, n, x);
+} // end vector_base::insert()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::insert(iterator position, InputIterator first, InputIterator last)
+{
+  // we could have received insert(position, n, x), so disambiguate on the
+  // type of InputIterator
+  typedef typename thrust::detail::is_integral<InputIterator> integral;
+
+  insert_dispatch(position, first, last, integral());
+} // end vector_base::insert()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::assign_dispatch(InputIterator first, InputIterator last, false_type)
+{
+  range_assign(first, last);
+} // end vector_base::assign_dispatch()
+
+template<typename T, typename Alloc>
+  template<typename Integral>
+    void vector_base<T,Alloc>
+      ::assign_dispatch(Integral n, Integral x, true_type)
+{
+  fill_assign(n, x);
+} // end vector_base::assign_dispatch()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::insert_dispatch(iterator position, InputIterator first, InputIterator last, false_type)
+{
+  copy_insert(position, first, last);
+} // end vector_base::insert_dispatch()
+
+template<typename T, typename Alloc>
+  template<typename Integral>
+    void vector_base<T,Alloc>
+      ::insert_dispatch(iterator position, Integral n, Integral x, true_type)
+{
+  fill_insert(position, n, x);
+} // end vector_base::insert_dispatch()
+
+template<typename T, typename Alloc>
+  template<typename ForwardIterator>
+    void vector_base<T,Alloc>
+      ::copy_insert(iterator position,
+                    ForwardIterator first,
+                    ForwardIterator last)
+{
+  if(first != last)
+  {
+    // how many new elements will we create?
+    const size_type num_new_elements = thrust::distance(first, last);
+    if(capacity() - size() >= num_new_elements)
+    {
+      // we've got room for all of them
+      // how many existing elements will we displace?
+      const size_type num_displaced_elements = end() - position;
+      iterator old_end = end();
+
+      if(num_displaced_elements > num_new_elements)
+      {
+        // construct copy n displaced elements to new elements
+        // following the insertion
+        m_storage.uninitialized_copy(end() - num_new_elements, end(), end());
+
+        // extend the size
+        m_size += num_new_elements;
+
+        // copy num_displaced_elements - num_new_elements elements to existing elements
+        // this copy overlaps
+        const size_type copy_length = (old_end - num_new_elements) - position;
+        thrust::detail::overlapped_copy(position, old_end - num_new_elements, old_end - copy_length);
+
+        // finally, copy the range to the insertion point
+        thrust::copy(first, last, position);
+      } // end if
+      else
+      {
+        ForwardIterator mid = first;
+        thrust::advance(mid, num_displaced_elements);
+
+        // construct copy new elements at the end of the vector
+        m_storage.uninitialized_copy(mid, last, end());
+
+        // extend the size
+        m_size += num_new_elements - num_displaced_elements;
+
+        // construct copy the displaced elements
+        m_storage.uninitialized_copy(position, old_end, end());
+
+        // extend the size
+        m_size += num_displaced_elements;
+
+        // copy to elements which already existed
+        thrust::copy(first, mid, position);
+      } // end else
+    } // end if
+    else
+    {
+      const size_type old_size = size();
+
+      // compute the new capacity after the allocation
+      size_type new_capacity = old_size + thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION (old_size, num_new_elements);
+
+      // allocate exponentially larger new storage
+      new_capacity = thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, 2 * capacity());
+
+      // do not exceed maximum storage
+      new_capacity = thrust::min THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, max_size());
+
+      if(new_capacity > max_size())
+      {
+        throw std::length_error("insert(): insertion exceeds max_size().");
+      } // end if
+
+      storage_type new_storage(copy_allocator_t(), m_storage, new_capacity);
+
+      // record how many constructors we invoke in the try block below
+      iterator new_end = new_storage.begin();
+
+      try
+      {
+        // construct copy elements before the insertion to the beginning of the newly
+        // allocated storage
+        new_end = m_storage.uninitialized_copy(begin(), position, new_storage.begin());
+
+        // construct copy elements to insert
+        new_end = m_storage.uninitialized_copy(first, last, new_end);
+
+        // construct copy displaced elements from the old storage to the new storage
+        // remember [position, end()) refers to the old storage
+        new_end = m_storage.uninitialized_copy(position, end(), new_end);
+      } // end try
+      catch(...)
+      {
+        // something went wrong, so destroy & deallocate the new storage
+        m_storage.destroy(new_storage.begin(), new_end);
+        new_storage.deallocate();
+
+        // rethrow
+        throw;
+      } // end catch
+
+      // call destructors on the elements in the old storage
+      m_storage.destroy(begin(), end());
+
+      // record the vector's new state
+      m_storage.swap(new_storage);
+      m_size = old_size + num_new_elements;
+    } // end else
+  } // end if
+} // end vector_base::copy_insert()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::append(size_type n)
+{
+  if(n != 0)
+  {
+    if(capacity() - size() >= n)
+    {
+      // we've got room for all of them
+
+      // default construct new elements at the end of the vector
+      m_storage.default_construct_n(end(), n);
+
+      // extend the size
+      m_size += n;
+    } // end if
+    else
+    {
+      const size_type old_size = size();
+
+      // compute the new capacity after the allocation
+      size_type new_capacity = old_size + thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION (old_size, n);
+
+      // allocate exponentially larger new storage
+      new_capacity = thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, 2 * capacity());
+
+      // do not exceed maximum storage
+      new_capacity = thrust::min THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, max_size());
+
+      // create new storage
+      storage_type new_storage(copy_allocator_t(), m_storage, new_capacity);
+
+      // record how many constructors we invoke in the try block below
+      iterator new_end = new_storage.begin();
+
+      try
+      {
+        // construct copy all elements into the newly allocated storage
+        new_end = m_storage.uninitialized_copy(begin(), end(), new_storage.begin());
+
+        // construct new elements to insert
+        new_storage.default_construct_n(new_end, n);
+        new_end += n;
+      } // end try
+      catch(...)
+      {
+        // something went wrong, so destroy & deallocate the new storage
+        new_storage.destroy(new_storage.begin(), new_end);
+        new_storage.deallocate();
+
+        // rethrow
+        throw;
+      } // end catch
+
+      // call destructors on the elements in the old storage
+      m_storage.destroy(begin(), end());
+
+      // record the vector's new state
+      m_storage.swap(new_storage);
+      m_size    = old_size + n;
+    } // end else
+  } // end if
+} // end vector_base::append()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::fill_insert(iterator position, size_type n, const T &x)
+{
+  if(n != 0)
+  {
+    if(capacity() - size() >= n)
+    {
+      // we've got room for all of them
+      // how many existing elements will we displace?
+      const size_type num_displaced_elements = end() - position;
+      iterator old_end = end();
+
+      if(num_displaced_elements > n)
+      {
+        // construct copy n displaced elements to new elements
+        // following the insertion
+        m_storage.uninitialized_copy(end() - n, end(), end());
+
+        // extend the size
+        m_size += n;
+
+        // copy num_displaced_elements - n elements to existing elements
+        // this copy overlaps
+        const size_type copy_length = (old_end - n) - position;
+        thrust::detail::overlapped_copy(position, old_end - n, old_end - copy_length);
+
+        // finally, fill the range to the insertion point
+        thrust::fill_n(position, n, x);
+      } // end if
+      else
+      {
+        // construct new elements at the end of the vector
+        m_storage.uninitialized_fill_n(end(), n - num_displaced_elements, x);
+
+        // extend the size
+        m_size += n - num_displaced_elements;
+
+        // construct copy the displaced elements
+        m_storage.uninitialized_copy(position, old_end, end());
+
+        // extend the size
+        m_size += num_displaced_elements;
+
+        // fill to elements which already existed
+        thrust::fill(position, old_end, x);
+      } // end else
+    } // end if
+    else
+    {
+      const size_type old_size = size();
+
+      // compute the new capacity after the allocation
+      size_type new_capacity = old_size + thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION (old_size, n);
+
+      // allocate exponentially larger new storage
+      new_capacity = thrust::max THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, 2 * capacity());
+
+      // do not exceed maximum storage
+      new_capacity = thrust::min THRUST_PREVENT_MACRO_SUBSTITUTION <size_type>(new_capacity, max_size());
+
+      if(new_capacity > max_size())
+      {
+        throw std::length_error("insert(): insertion exceeds max_size().");
+      } // end if
+
+      storage_type new_storage(copy_allocator_t(), m_storage, new_capacity);
+
+      // record how many constructors we invoke in the try block below
+      iterator new_end = new_storage.begin();
+
+      try
+      {
+        // construct copy elements before the insertion to the beginning of the newly
+        // allocated storage
+        new_end = m_storage.uninitialized_copy(begin(), position, new_storage.begin());
+
+        // construct new elements to insert
+        m_storage.uninitialized_fill_n(new_end, n, x);
+        new_end += n;
+
+        // construct copy displaced elements from the old storage to the new storage
+        // remember [position, end()) refers to the old storage
+        new_end = m_storage.uninitialized_copy(position, end(), new_end);
+      } // end try
+      catch(...)
+      {
+        // something went wrong, so destroy & deallocate the new storage
+        m_storage.destroy(new_storage.begin(), new_end);
+        new_storage.deallocate();
+
+        // rethrow
+        throw;
+      } // end catch
+
+      // call destructors on the elements in the old storage
+      m_storage.destroy(begin(), end());
+
+      // record the vector's new state
+      m_storage.swap(new_storage);
+      m_size    = old_size + n;
+    } // end else
+  } // end if
+} // end vector_base::fill_insert()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::range_assign(InputIterator first,
+                     InputIterator last)
+{
+  // dispatch on traversal
+  range_assign(first, last,
+    typename thrust::iterator_traversal<InputIterator>::type());
+} // end range_assign()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+    void vector_base<T,Alloc>
+      ::range_assign(InputIterator first,
+                     InputIterator last,
+                     thrust::incrementable_traversal_tag)
+{
+  iterator current(begin());
+
+  // assign to elements which already exist
+  for(; first != last && current != end(); ++current, ++first)
+  {
+    *current = *first;
+  } // end for
+
+  // either just the input was exhausted or both
+  // the input and vector elements were exhausted
+  if(first == last)
+  {
+    // if we exhausted the input, erase leftover elements
+    erase(current, end());
+  } // end if
+  else
+  {
+    // insert the rest of the input at the end of the vector
+    insert(end(), first, last);
+  } // end else
+} // end vector_base::range_assign()
+
+template<typename T, typename Alloc>
+  template<typename RandomAccessIterator>
+    void vector_base<T,Alloc>
+      ::range_assign(RandomAccessIterator first,
+                     RandomAccessIterator last,
+                     thrust::random_access_traversal_tag)
+{
+  const size_type n = thrust::distance(first, last);
+
+  if(n > capacity())
+  {
+    storage_type new_storage(copy_allocator_t(), m_storage);
+    allocate_and_copy(n, first, last, new_storage);
+
+    // call destructors on the elements in the old storage
+    m_storage.destroy(begin(), end());
+
+    // record the vector's new state
+    m_storage.swap(new_storage);
+    m_size = n;
+  } // end if
+  else if(size() >= n)
+  {
+    // we can already accomodate the new range
+    iterator new_end = thrust::copy(first, last, begin());
+
+    // destroy the elements we don't need
+    m_storage.destroy(new_end, end());
+
+    // update size
+    m_size = n;
+  } // end else if
+  else
+  {
+    // range fits inside allocated storage, but some elements
+    // have not been constructed yet
+
+    // XXX TODO we could possibly implement this with one call
+    // to transform rather than copy + uninitialized_copy
+
+    // copy to elements which already exist
+    RandomAccessIterator mid = first;
+    thrust::advance(mid, size());
+    thrust::copy(first, mid, begin());
+
+    // uninitialize_copy to elements which must be constructed
+    m_storage.uninitialized_copy(mid, last, end());
+
+    // update size
+    m_size = n;
+  } // end else
+} // end vector_base::assign()
+
+template<typename T, typename Alloc>
+  void vector_base<T,Alloc>
+    ::fill_assign(size_type n, const T &x)
+{
+  if(n > capacity())
+  {
+    // XXX we should also include a copy of the allocator:
+    // vector_base<T,Alloc> temp(n, x, get_allocator());
+    vector_base<T,Alloc> temp(n, x);
+    temp.swap(*this);
+  } // end if
+  else if(n > size())
+  {
+    // fill to existing elements
+    thrust::fill(begin(), end(), x);
+
+    // construct uninitialized elements
+    m_storage.uninitialized_fill_n(end(), n - size(), x);
+
+    // adjust size
+    m_size += (n - size());
+  } // end else if
+  else
+  {
+    // fill to existing elements
+    iterator new_end = thrust::fill_n(begin(), n, x);
+
+    // erase the elements after the fill
+    erase(new_end, end());
+  } // end else
+} // end vector_base::fill_assign()
+
+template<typename T, typename Alloc>
+  template<typename ForwardIterator>
+    void vector_base<T,Alloc>
+      ::allocate_and_copy(size_type requested_size,
+                          ForwardIterator first, ForwardIterator last,
+                          storage_type &new_storage)
+{
+  if(requested_size == 0)
+  {
+    new_storage.deallocate();
+    return;
+  } // end if
+
+  // allocate exponentially larger new storage
+  size_type allocated_size = thrust::max<size_type>(requested_size, 2 * capacity());
+
+  // do not exceed maximum storage
+  allocated_size = thrust::min<size_type>(allocated_size, max_size());
+
+  if(requested_size > allocated_size)
+  {
+    throw std::length_error("assignment exceeds max_size().");
+  } // end if
+
+  new_storage.allocate(allocated_size);
+
+  try
+  {
+    // construct the range to the newly allocated storage
+    m_storage.uninitialized_copy(first, last, new_storage.begin());
+  } // end try
+  catch(...)
+  {
+    // something went wrong, so destroy & deallocate the new storage
+    // XXX seems like this destroys too many elements -- should just be last - first instead of requested_size
+    iterator new_storage_end = new_storage.begin();
+    thrust::advance(new_storage_end, requested_size);
+    m_storage.destroy(new_storage.begin(), new_storage_end);
+    new_storage.deallocate();
+
+    // rethrow
+    throw;
+  } // end catch
+} // end vector_base::allocate_and_copy()
+
+
+} // end detail
+
+template<typename T, typename Alloc>
+  void swap(detail::vector_base<T,Alloc> &a,
+            detail::vector_base<T,Alloc> &b)
+{
+  a.swap(b);
+} // end swap()
+
+
+
+namespace detail
+{
+
+// iterator tags match
+template <typename InputIterator1, typename InputIterator2>
+bool vector_equal(InputIterator1 first1, InputIterator1 last1,
+                  InputIterator2 first2,
+                  thrust::detail::true_type)
+{
+  return thrust::equal(first1, last1, first2);
+}
+
+// iterator tags differ
+template <typename InputIterator1, typename InputIterator2>
+bool vector_equal(InputIterator1 first1, InputIterator1 last1,
+                  InputIterator2 first2,
+                  thrust::detail::false_type)
+{
+  typename thrust::iterator_difference<InputIterator1>::type n = thrust::distance(first1,last1);
+
+  typedef typename thrust::iterator_system<InputIterator1>::type FromSystem1;
+  typedef typename thrust::iterator_system<InputIterator2>::type FromSystem2;
+
+  // bring both ranges to the host system
+  // note that these copies are no-ops if the range is already convertible to the host system
+  FromSystem1 from_system1;
+  FromSystem2 from_system2;
+  thrust::host_system_tag to_system;
+  thrust::detail::move_to_system<InputIterator1, FromSystem1, thrust::host_system_tag> rng1(from_system1, to_system, first1, last1);
+  thrust::detail::move_to_system<InputIterator2, FromSystem2, thrust::host_system_tag> rng2(from_system2, to_system, first2, first2 + n);
+
+  return thrust::equal(rng1.begin(), rng1.end(), rng2.begin());
+}
+
+template <typename InputIterator1, typename InputIterator2>
+bool vector_equal(InputIterator1 first1, InputIterator1 last1,
+                  InputIterator2 first2)
+{
+  typedef typename thrust::iterator_system<InputIterator1>::type system1;
+  typedef typename thrust::iterator_system<InputIterator2>::type system2;
+
+  // dispatch on the sameness of the two systems
+  return vector_equal(first1, last1, first2,
+    thrust::detail::is_same<system1,system2>());
+}
+
+} // end namespace detail
+
+
+
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const detail::vector_base<T1,Alloc1>& lhs,
+                const detail::vector_base<T2,Alloc2>& rhs)
+{
+    return lhs.size() == rhs.size() && detail::vector_equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const detail::vector_base<T1,Alloc1>& lhs,
+                const std::vector<T2,Alloc2>&         rhs)
+{
+    return lhs.size() == rhs.size() && detail::vector_equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator==(const std::vector<T1,Alloc1>&         lhs,
+                const detail::vector_base<T2,Alloc2>& rhs)
+{
+    return lhs.size() == rhs.size() && detail::vector_equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const detail::vector_base<T1,Alloc1>& lhs,
+                const detail::vector_base<T2,Alloc2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const detail::vector_base<T1,Alloc1>& lhs,
+                const std::vector<T2,Alloc2>&         rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename T1, typename Alloc1,
+         typename T2, typename Alloc2>
+bool operator!=(const std::vector<T1,Alloc1>&         lhs,
+                const detail::vector_base<T2,Alloc2>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..f64c3854f0ee66a69b4831c83d17d0f96adb40f9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_allocator.h
@@ -0,0 +1,140 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file
+ *  \brief An allocator which creates new elements in memory accessible by
+ *  devices.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/device_memory_resource.h>
+
+#include <limits>
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+/** \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! Memory resource adaptor that turns any memory resource that returns a fancy
+ *      with the same tag as \p device_ptr, and adapts it to a resource that returns
+ *      a \p device_ptr.
+ */
+template<typename Upstream>
+class device_ptr_memory_resource final
+    : public thrust::mr::memory_resource<
+        device_ptr<void>
+    >
+{
+    typedef typename Upstream::pointer upstream_ptr;
+
+public:
+    /*! Initialize the adaptor with the global instance of the upstream resource. Obtains
+     *      the global instance by calling \p get_global_resource.
+     */
+    __host__
+    device_ptr_memory_resource() : m_upstream(mr::get_global_resource<Upstream>())
+    {
+    }
+
+    /*! Initialize the adaptor with an upstream resource.
+     *
+     *  \param upstream the upstream memory resource to adapt.
+     */
+    __host__
+    device_ptr_memory_resource(Upstream * upstream) : m_upstream(upstream)
+    {
+    }
+
+    THRUST_NODISCARD __host__
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return pointer(m_upstream->do_allocate(bytes, alignment).get());
+    }
+
+    __host__
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        m_upstream->do_deallocate(upstream_ptr(p.get()), bytes, alignment);
+    }
+
+private:
+    Upstream * m_upstream;
+};
+
+/*! \brief An allocator which creates new elements in memory accessible by
+ *         devices.
+ *
+ *  \see https://en.cppreference.com/w/cpp/named_req/Allocator
+ */
+template<typename T>
+class device_allocator
+    : public thrust::mr::stateless_resource_allocator<
+        T,
+        device_ptr_memory_resource<device_memory_resource>
+    >
+{
+    typedef thrust::mr::stateless_resource_allocator<
+        T,
+        device_ptr_memory_resource<device_memory_resource>
+    > base;
+
+public:
+    /*! The \p rebind metafunction provides the type of a \p device_allocator
+     *  instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p device_allocator.
+         */
+        typedef device_allocator<U> other;
+    };
+
+    /*! Default constructor has no effect. */
+    __host__ __device__
+    device_allocator() {}
+
+    /*! Copy constructor has no effect. */
+    __host__ __device__
+    device_allocator(const device_allocator& other) : base(other) {}
+
+    /*! Constructor from other \p device_allocator has no effect. */
+    template<typename U>
+    __host__ __device__
+    device_allocator(const device_allocator<U>& other) : base(other) {}
+
+    device_allocator & operator=(const device_allocator &) = default;
+
+    /*! Destructor has no effect. */
+    __host__ __device__
+    ~device_allocator() {}
+};
+
+/*! \} // allocators
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_delete.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_delete.h
new file mode 100644
index 0000000000000000000000000000000000000000..0811936fbbe7ab7783e65052d844db19575d45ce
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_delete.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.
+ */
+
+/*! \file
+ *  \brief Deletes variables in device memory.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_delete deletes a \p device_ptr allocated with
+ *  \p device_new.
+ *
+ *  \param ptr The \p device_ptr to delete, assumed to have
+ *         been allocated with \p device_new.
+ *  \param n The number of objects to destroy at \p ptr. Defaults to \c 1
+ *         similar to \p device_new.
+ *
+ *  \see device_ptr
+ *  \see device_new
+ */
+template<typename T>
+  inline void device_delete(thrust::device_ptr<T> ptr,
+                            const size_t n = 1);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_delete.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_free.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_free.h
new file mode 100644
index 0000000000000000000000000000000000000000..1cd305045e425ebccd17e98b4f1e496fe5652c60
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_free.h
@@ -0,0 +1,65 @@
+/*
+ *  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 Deallocates storage allocated by \p device_malloc.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_free deallocates memory allocated by the function \p device_malloc.
+ *
+ *  \param ptr A \p device_ptr pointing to memory to be deallocated.
+ *
+ *  The following code snippet demonstrates how to use \p device_free to
+ *  deallocate memory allocated by \p device_malloc.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some integers with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<int> int_array = thrust::device_malloc<int>(N);
+ *
+ *  // manipulate integers
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(int_array);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_malloc
+ */
+inline void device_free(thrust::device_ptr<void> ptr);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_free.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_make_unique.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_make_unique.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdb8c31d82ff987b591f305db450d341958615cb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_make_unique.h
@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file device_make_unique.h
+ *  \brief A factory function for creating `unique_ptr`s to device objects.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/allocate_unique.h>
+#include <thrust/device_new.h>
+#include <thrust/device_ptr.h>
+#include <thrust/device_allocator.h>
+#include <thrust/detail/type_deduction.h>
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename... Args>
+__host__
+auto device_make_unique(Args&&... args)
+  THRUST_TRAILING_RETURN(decltype(
+    uninitialized_allocate_unique<T>(device_allocator<T>{})
+  ))
+{
+#if !defined(THRUST_DOXYGEN) // This causes Doxygen to choke for some reason.
+  // FIXME: This is crude - we construct an unnecessary T on the host for
+  // `device_new`. We need a proper dispatched `construct` algorithm to
+  // do this properly.
+  auto p = uninitialized_allocate_unique<T>(device_allocator<T>{});
+  device_new<T>(p.get(), T(THRUST_FWD(args)...));
+  return p;
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..790ddbac3a7d809e49934f7001a20babaa7e717d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc.h
@@ -0,0 +1,100 @@
+/*
+ *  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 Allocates storage in device memory.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+#include <cstddef> // for std::size_t
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! This version of \p device_malloc allocates sequential device storage
+ *  for bytes.
+ *
+ *  \param n The number of bytes to allocate sequentially
+ *           in device memory.
+ *  \return A \p device_ptr to the newly allocated memory.
+ *
+ *  The following code snippet demonstrates how to use \p device_malloc to
+ *  allocate a range of device memory.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some memory with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<void> void_ptr = thrust::device_malloc(N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(void_ptr);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_free
+ */
+inline thrust::device_ptr<void> device_malloc(const std::size_t n);
+
+/*! This version of \p device_malloc allocates sequential device storage for
+ *  new objects of the given type.
+ *
+ *  \param n The number of objects of type T to allocate
+ *           sequentially in device memory.
+ *  \return A \p device_ptr to the newly allocated memory.
+ *
+ *  The following code snippet demonstrates how to use \p device_malloc to
+ *  allocate a range of device memory.
+ *
+ *  \code
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_free.h>
+ *  ...
+ *  // allocate some integers with device_malloc
+ *  const int N = 100;
+ *  thrust::device_ptr<int> int_array = thrust::device_malloc<int>(N);
+ *
+ *  // manipulate integers
+ *  ...
+ *
+ *  // deallocate with device_free
+ *  thrust::device_free(int_array);
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_free
+ */
+template<typename T>
+  inline thrust::device_ptr<T> device_malloc(const std::size_t n);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_malloc.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b15045f2f8b2d7cda3c39b666cd94aa400abff7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_malloc_allocator.h
@@ -0,0 +1,180 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file 
+ *  \brief An allocator which allocates storage with \p device_malloc.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+#include <thrust/device_reference.h>
+#include <thrust/device_malloc.h>
+#include <thrust/device_free.h>
+#include <limits>
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declarations to WAR circular #includes
+template<typename> class device_ptr;
+template<typename T> device_ptr<T> device_malloc(const std::size_t n);
+
+/*! \addtogroup allocators Allocators 
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p device_malloc_allocator is a device memory allocator that employs the
+ *  \p device_malloc function for allocation.
+ *
+ *  \p device_malloc_allocator is deprecated in favor of <tt>thrust::mr</tt>
+ *      memory resource-based allocators.
+ *
+ *  \see device_malloc
+ *  \see device_ptr
+ *  \see device_allocator
+ *  \see https://en.cppreference.com/w/cpp/memory/allocator
+ */
+template<typename T>
+  class device_malloc_allocator
+{
+  public:
+    /*! Type of element allocated, \c T. */
+    typedef T                                 value_type;
+
+    /*! Pointer to allocation, \c device_ptr<T>. */
+    typedef device_ptr<T>                     pointer;
+
+    /*! \c const pointer to allocation, \c device_ptr<const T>. */
+    typedef device_ptr<const T>               const_pointer;
+
+    /*! Reference to allocated element, \c device_reference<T>. */
+    typedef device_reference<T>               reference;
+
+    /*! \c const reference to allocated element, \c device_reference<const T>. */
+    typedef device_reference<const T>         const_reference;
+
+    /*! Type of allocation size, \c std::size_t. */
+    typedef std::size_t                       size_type;
+
+    /*! Type of allocation difference, \c pointer::difference_type. */
+    typedef typename pointer::difference_type difference_type;
+
+    /*! The \p rebind metafunction provides the type of a \p device_malloc_allocator
+     *  instantiated with another type.
+     *
+     *  \tparam U The other type to use for instantiation.
+     */
+    template<typename U>
+      struct rebind
+    {
+      /*! The typedef \p other gives the type of the rebound \p device_malloc_allocator.
+       */
+      typedef device_malloc_allocator<U> other;
+    }; // end rebind
+
+    /*! No-argument constructor has no effect. */
+    __host__ __device__
+    inline device_malloc_allocator() {}
+
+    /*! No-argument destructor has no effect. */
+    __host__ __device__
+    inline ~device_malloc_allocator() {}
+
+    /*! Copy constructor has no effect. */
+    __host__ __device__
+    inline device_malloc_allocator(device_malloc_allocator const&) {}
+
+    /*! Constructor from other \p device_malloc_allocator has no effect. */
+    template<typename U>
+    __host__ __device__
+    inline device_malloc_allocator(device_malloc_allocator<U> const&) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    device_malloc_allocator & operator=(const device_malloc_allocator &) = default;
+#endif
+
+    /*! Returns the address of an allocated object.
+     *  \return <tt>&r</tt>.
+     */
+    __host__ __device__
+    inline pointer address(reference r) { return &r; }
+
+    /*! Returns the address an allocated object.
+     *  \return <tt>&r</tt>.
+     */
+    __host__ __device__
+    inline const_pointer address(const_reference r) { return &r; }
+
+    /*! Allocates storage for \p cnt objects.
+     *  \param cnt The number of objects to allocate.
+     *  \return A \p pointer to uninitialized storage for \p cnt objects.
+     *  \note Memory allocated by this function must be deallocated with \p deallocate.
+     */
+    __host__
+    inline pointer allocate(size_type cnt,
+                            const_pointer = const_pointer(static_cast<T*>(0)))
+    {
+      if(cnt > this->max_size())
+      {
+        throw std::bad_alloc();
+      } // end if
+
+      return pointer(device_malloc<T>(cnt));
+    } // end allocate()
+
+    /*! Deallocates storage for objects allocated with \p allocate.
+     *  \param p A \p pointer to the storage to deallocate.
+     *  \param cnt The size of the previous allocation.
+     *  \note Memory deallocated by this function must previously have been
+     *        allocated with \p allocate.
+     */
+    __host__
+    inline void deallocate(pointer p, size_type cnt)
+    {
+      // silence unused parameter warning while still leaving the parameter name for Doxygen
+      (void)(cnt);
+
+      device_free(p);
+    } // end deallocate()
+
+    /*! Returns the largest value \c n for which <tt>allocate(n)</tt> might succeed.
+     *  \return The largest value \c n for which <tt>allocate(n)</tt> might succeed.
+     */
+    inline size_type max_size() const
+    {
+      return (std::numeric_limits<size_type>::max)() / sizeof(T);
+    } // end max_size()
+
+    /*! Compares against another \p device_malloc_allocator for equality.
+     *  \return \c true
+     */
+    __host__ __device__
+    inline bool operator==(device_malloc_allocator const&) const { return true; }
+
+    /*! Compares against another \p device_malloc_allocator for inequality.
+     *  \return \c false
+     */
+    __host__ __device__
+    inline bool operator!=(device_malloc_allocator const &a) const {return !operator==(a); }
+}; // end device_malloc_allocator
+
+/*! \} // allocators
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new.h
new file mode 100644
index 0000000000000000000000000000000000000000..c615e58f2d6ac548866cff0f1a8f0365c5e297b6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new.h
@@ -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.
+ */
+
+
+/*! \file device_new.h
+ *  \brief Constructs new elements in device memory
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #include this for size_t
+#include <cstddef>
+#include <thrust/device_ptr.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*!
+ *  \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_new implements the placement \c new operator for types
+ *  resident in device memory. \p device_new calls <tt>T</tt>'s null
+ *  constructor on a array of objects in device memory.
+ *  No memory is allocated by this function.
+ *
+ *  \param  p A \p device_ptr to a region of device memory into which
+ *          to construct one or many <tt>T</tt>s.
+ *  \param  n The number of objects to construct at \p p.
+ *  \return p, casted to <tt>T</tt>'s type.
+ *
+ *  \see device_ptr
+ */
+template <typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const size_t n = 1);
+
+/*! \p device_new implements the placement new operator for types
+ *  resident in device memory. \p device_new calls <tt>T</tt>'s copy
+ *  constructor on a array of objects in device memory. No memory is
+ *  allocated by this function.
+ *
+ *  \param  p A \p device_ptr to a region of device memory into which to
+ *          construct one or many <tt>T</tt>s.
+ *  \param exemplar The value from which to copy.
+ *  \param  n The number of objects to construct at \p p.
+ *  \return p, casted to <tt>T</tt>'s type.
+ *
+ *  \see device_ptr
+ *  \see fill
+ */
+template <typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const T &exemplar,
+                           const size_t n = 1);
+
+/*! \p device_new implements the new operator for types resident in device memory.
+ *  It allocates device memory large enough to hold \p n new objects of type \c T.
+ *
+ *  \param n The number of objects to allocate. Defaults to \c 1.
+ *  \return A \p device_ptr to the newly allocated region of device memory.
+ */
+template <typename T>
+  device_ptr<T> device_new(const size_t n = 1);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_new.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9c6b0e9507fd42efe203ff770eaa048339700be
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_new_allocator.h
@@ -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.
+ */
+
+/*! \file 
+ *  \brief An allocator which allocates storage with \p device_new.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+#include <thrust/device_reference.h>
+#include <thrust/device_new.h>
+#include <thrust/device_delete.h>
+
+#include <cuda/std/cstdint>
+#include <cuda/std/limits>
+
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p device_new_allocator is a device memory allocator that employs the
+ *  \p device_new function for allocation.
+ *
+ *  \see device_new
+ *  \see device_ptr
+ *  \see https://en.cppreference.com/w/cpp/memory/allocator
+ */
+template<typename T>
+  class device_new_allocator
+{
+  public:
+    /*! Type of element allocated, \c T. */
+    typedef T                                 value_type;
+
+    /*! Pointer to allocation, \c device_ptr<T>. */
+    typedef device_ptr<T>                     pointer;
+
+    /*! \c const pointer to allocation, \c device_ptr<const T>. */
+    typedef device_ptr<const T>               const_pointer;
+
+    /*! Reference to allocated element, \c device_reference<T>. */
+    typedef device_reference<T>               reference;
+
+    /*! \c const reference to allocated element, \c device_reference<const T>. */
+    typedef device_reference<const T>         const_reference;
+
+    /*! Type of allocation size, \c ::cuda::std::size_t. */
+    typedef ::cuda::std::size_t                 size_type;
+
+    /*! Type of allocation difference, \c pointer::difference_type. */
+    typedef typename pointer::difference_type difference_type;
+
+    /*! The \p rebind metafunction provides the type of a \p device_new_allocator
+     *  instantiated with another type.
+     *
+     *  \tparam U The other type to use for instantiation.
+     */
+    template<typename U>
+      struct rebind
+    {
+      /*! The typedef \p other gives the type of the rebound \p device_new_allocator.
+       */
+      typedef device_new_allocator<U> other;
+    }; // end rebind
+
+    /*! No-argument constructor has no effect. */
+    __host__ __device__
+    inline device_new_allocator() {}
+
+    /*! No-argument destructor has no effect. */
+    __host__ __device__
+    inline ~device_new_allocator() {}
+
+    /*! Copy constructor has no effect. */
+    __host__ __device__
+    inline device_new_allocator(device_new_allocator const&) {}
+
+    /*! Constructor from other \p device_malloc_allocator has no effect. */
+    template<typename U>
+    __host__ __device__
+    inline device_new_allocator(device_new_allocator<U> const&) {}
+
+    /*! Returns the address of an allocated object.
+     *  \return <tt>&r</tt>.
+     */
+    __host__ __device__
+    inline pointer address(reference r) { return &r; }
+    
+    /*! Returns the address an allocated object.
+     *  \return <tt>&r</tt>.
+     */
+    __host__ __device__
+    inline const_pointer address(const_reference r) { return &r; }
+
+    /*! Allocates storage for \p cnt objects.
+     *  \param cnt The number of objects to allocate.
+     *  \return A \p pointer to uninitialized storage for \p cnt objects.
+     *  \note Memory allocated by this function must be deallocated with \p deallocate.
+     */
+    __host__
+    inline pointer allocate(size_type cnt,
+                            const_pointer = const_pointer(static_cast<T*>(0)))
+    {
+      if(cnt > this->max_size())
+      {
+        throw std::bad_alloc();
+      } // end if
+
+      // use "::operator new" rather than keyword new
+      return pointer(device_new<T>(cnt));
+    } // end allocate()
+
+    /*! Deallocates storage for objects allocated with \p allocate.
+     *  \param p A \p pointer to the storage to deallocate.
+     *  \param cnt The size of the previous allocation.
+     *  \note Memory deallocated by this function must previously have been
+     *        allocated with \p allocate.
+     */
+    __host__
+    inline void deallocate(pointer p, size_type cnt)
+    {
+      // use "::operator delete" rather than keyword delete
+      (void)cnt;
+      device_delete(p);
+    } // end deallocate()
+
+    /*! Returns the largest value \c n for which <tt>allocate(n)</tt> might succeed.
+     *  \return The largest value \c n for which <tt>allocate(n)</tt> might succeed.
+     */
+    __host__ __device__
+    inline size_type max_size() const
+    {
+      return ::cuda::std::numeric_limits<size_type>::max THRUST_PREVENT_MACRO_SUBSTITUTION () / sizeof(T);
+    } // end max_size()
+
+    /*! Compares against another \p device_malloc_allocator for equality.
+     *  \return \c true
+     */
+    __host__ __device__
+    inline bool operator==(device_new_allocator const&) { return true; }
+
+    /*! Compares against another \p device_malloc_allocator for inequality.
+     *  \return \c false
+     */
+    __host__ __device__
+    inline bool operator!=(device_new_allocator const &a) {return !operator==(a); }
+}; // end device_new_allocator
+
+/*! \} // allocators
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_ptr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ef4aa464fcd93fdbef22598b7f96a475da6aa47
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_ptr.h
@@ -0,0 +1,211 @@
+/*
+ *  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 an object which resides in memory associated with the
+ *  \c device system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/memory.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+template <typename T> class device_reference;
+
+/*! \brief \c device_ptr is a pointer-like object which points to an object that
+ *  resides in memory associated with the \ref device system.
+ *
+ *  \c device_ptr has pointer semantics: it may be dereferenced safely from
+ *  anywhere, including the \ref host, and may be manipulated with pointer
+ *  arithmetic.
+ *
+ *  \c device_ptr can be created with \ref device_new, \ref device_malloc,
+ *  \ref device_malloc_allocator, \ref device_allocator, or
+ *  \ref device_pointer_cast, or by explicitly calling its constructor with a
+ *  raw pointer.
+ *
+ *  The raw pointer contained in a \c device_ptr may be obtained via \c get
+ *  member function or the \ref raw_pointer_cast free function.
+ *
+ *  \ref algorithms operating on \c device_ptr types will automatically be
+ *  dispatched to the \ref device system.
+ *
+ *  \note \c device_ptr is not a smart pointer; it is the programmer's
+ *  responsibility to deallocate memory pointed to by \c device_ptr.
+ *
+ *  \see device_new
+ *  \see device_malloc
+ *  \see device_malloc_allocator
+ *  \see device_allocator
+ *  \see device_pointer_cast
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+class device_ptr
+  : public thrust::pointer<
+      T,
+      thrust::device_system_tag,
+      thrust::device_reference<T>,
+      thrust::device_ptr<T>
+    >
+{
+  private:
+    using super_t = thrust::pointer<
+      T,
+      thrust::device_system_tag,
+      thrust::device_reference<T>,
+      thrust::device_ptr<T>
+    >;
+
+  public:
+    /*! \brief Construct a null \c device_ptr.
+     *
+     *  \post <tt>get() == nullptr</tt>.
+     */
+    __host__ __device__
+    device_ptr() : super_t() {}
+
+    /*! \brief Construct a null \c device_ptr.
+     *
+     *  \param ptr A null pointer.
+     *
+     *  \post <tt>get() == nullptr</tt>.
+     */
+    __host__ __device__
+    device_ptr(std::nullptr_t) : super_t(nullptr) {}
+
+    /*! \brief Construct a \c device_ptr from a raw pointer which is
+     *  convertible to \c T*.
+     *
+     *  \tparam U   A type whose pointer is convertible to \c T*.
+     *  \param  ptr A raw pointer to a \c U in device memory to construct from.
+     *
+     *  \pre <tt>std::is_convertible_v<U*, T*> == true</tt>.
+     *
+     *  \pre \c ptr points to a location in device memory.
+     *
+     *  \post <tt>get() == nullptr</tt>.
+     */
+    template <typename U>
+    __host__ __device__
+    explicit device_ptr(U* ptr) : super_t(ptr) {}
+
+    /*! \brief Copy construct a \c device_ptr from another \c device_ptr whose
+     *  pointer type is convertible to \c T*.
+     *
+     *  \tparam U     A type whose pointer is convertible to \c T*.
+     *  \param  other A \c device_ptr to a \c U to construct from.
+     *
+     *  \pre <tt>std::is_convertible_v<U*, T*> == true</tt>.
+     *
+     *  \post <tt>get() == other.get()</tt>.
+     */
+    template <typename U>
+    __host__ __device__
+    device_ptr(device_ptr<U> const& other) : super_t(other) {}
+
+    /*! \brief Set this \c device_ptr to point to the same object as another
+     *  \c device_ptr whose pointer type is convertible to \c T*.
+     *
+     *  \tparam U     A type whose pointer is convertible to \c T*.
+     *  \param  other A \c device_ptr to a \c U to assign from.
+     *
+     *  \pre <tt>std::is_convertible_v<U*, T*> == true</tt>.
+     *
+     *  \post <tt>get() == other.get()</tt>.
+     *
+     *  \return \c *this.
+     */
+    template <typename U>
+    __host__ __device__
+    device_ptr &operator=(device_ptr<U> const& other)
+    {
+      super_t::operator=(other);
+      return *this;
+    }
+
+    /*! \brief Set this \c device_ptr to null.
+     *
+     *  \param ptr A null pointer.
+     *
+     *  \post <tt>get() == nullptr</tt>.
+     *
+     *  \return \c *this.
+     */
+    __host__ __device__
+    device_ptr& operator=(std::nullptr_t)
+    {
+      super_t::operator=(nullptr);
+      return *this;
+    }
+
+#if THRUST_DOXYGEN
+    /*! \brief Return the raw pointer that this \c device_ptr points to.
+     */
+    __host__ __device__
+    T* get() const;
+#endif
+};
+
+#if THRUST_DOXYGEN
+/*! Write the address that a \c device_ptr points to to an output stream.
+ *
+ *  \param os The output stream.
+ *  \param dp The \c device_ptr to output.
+ *
+ *  \return \c os.
+ */
+template <typename T, typename CharT, typename Traits>
+__host__ std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, device_ptr<T> const& dp);
+#endif
+
+/*! \brief Create a \c device_ptr from a raw pointer.
+ *
+ *  \tparam T   Any type.
+ *  \param  ptr A raw pointer to a \c T in device memory.
+ *
+ *  \pre \c ptr points to a location in device memory.
+ *
+ *  \return A \c device_ptr<T> pointing to \c ptr.
+ */
+template <typename T>
+__host__ __device__
+device_ptr<T> device_pointer_cast(T* ptr);
+
+/*! \brief Create a \c device_ptr from another \c device_ptr.
+ *
+ *  \tparam T    Any type.
+ *  \param  dptr A \c device_ptr to a \c T.
+ */
+template<typename T>
+__host__ __device__
+device_ptr<T> device_pointer_cast(device_ptr<T> const& dptr);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/device_ptr.inl>
+#include <thrust/detail/raw_pointer_cast.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_reference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..512ab4c60c36cb030b579881008de44c1b17fb08
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_reference.h
@@ -0,0 +1,987 @@
+/*
+ *  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 reference to an object which resides in memory associated with the
+ *  device system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_ptr.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/reference.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+/*! \p device_reference acts as a reference-like object to an object stored in device memory.
+ *  \p device_reference is not intended to be used directly; rather, this type
+ *  is the result of deferencing a \p device_ptr. Similarly, taking the address of
+ *  a \p device_reference yields a \p device_ptr.
+ *
+ *  \p device_reference may often be used from host code in place of operations defined on
+ *  its associated \c value_type. For example, when \p device_reference refers to an
+ *  arithmetic type, arithmetic operations on it are legal:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    thrust::device_reference<int> ref_to_thirteen = vec[0];
+ *
+ *    int x = ref_to_thirteen + 1;
+ *
+ *    // x is 14
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Similarly, we can print the value of \c ref_to_thirteen in the above code by using an
+ *  \c iostream:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    thrust::device_reference<int> ref_to_thirteen = vec[0];
+ *
+ *    std::cout << ref_to_thirteen << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Of course, we needn't explicitly create a \p device_reference in the previous
+ *  example, because one is returned by \p device_vector's bracket operator. A more natural
+ *  way to print the value of a \p device_vector element might be:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<int> vec(1, 13);
+ *
+ *    std::cout << vec[0] << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  These kinds of operations should be used sparingly in performance-critical code, because
+ *  they imply a potentially expensive copy between host and device space.
+ *
+ *  Some operations which are possible with regular objects are impossible with their
+ *  corresponding \p device_reference objects due to the requirements of the C++ language. For
+ *  example, because the member access operator cannot be overloaded, member variables and functions
+ *  of a referent object cannot be directly accessed through its \p device_reference.
+ *
+ *  The following code, which generates a compiler error, illustrates:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct foo
+ *  {
+ *    int x;
+ *  };
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<foo> foo_vec(1);
+ *
+ *    thrust::device_reference<foo> foo_ref = foo_vec[0];
+ *
+ *    foo_ref.x = 13; // ERROR: x cannot be accessed through foo_ref
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Instead, a host space copy must be created to access \c foo's \c x member:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct foo
+ *  {
+ *    int x;
+ *  };
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<foo> foo_vec(1);
+ *
+ *    // create a local host-side foo object
+ *    foo host_foo;
+ *    host_foo.x = 13;
+ *
+ *    thrust::device_reference<foo> foo_ref = foo_vec[0];
+ *
+ *    foo_ref = host_foo;
+ *
+ *    // foo_ref's x member is 13
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Another common case where a \p device_reference cannot directly be used in place of
+ *  its referent object occurs when passing them as parameters to functions like \c printf
+ *  which have varargs parameters. Because varargs parameters must be Plain Old Data, a
+ *  \p device_reference to a POD type requires a cast when passed to \c printf:
+ *
+ *  \code
+ *  #include <stdio.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main(void)
+ *  {
+ *    thrust::device_vector<int> vec(1,13);
+ *
+ *    // vec[0] must be cast to int when passing to printf
+ *    printf("%d\n", (int) vec[0]);
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see device_ptr
+ *  \see device_vector
+ */
+template<typename T>
+  class device_reference
+    : public thrust::reference<
+               T,
+               thrust::device_ptr<T>,
+               thrust::device_reference<T>
+             >
+{
+  private:
+    typedef thrust::reference<
+      T,
+      thrust::device_ptr<T>,
+      thrust::device_reference<T>
+    > super_t;
+
+  public:
+    /*! The type of the value referenced by this type of \p device_reference.
+     */
+    typedef typename super_t::value_type value_type;
+
+    /*! The type of the expression <tt>&ref</tt>, where <tt>ref</tt> is a \p device_reference.
+     */
+    typedef typename super_t::pointer    pointer;
+
+    /*! This copy constructor accepts a const reference to another
+     *  \p device_reference. After this \p device_reference is constructed,
+     *  it shall refer to the same object as \p other.
+     *
+     *  \param other A \p device_reference to copy from.
+     *
+     *  The following code snippet demonstrates the semantics of this
+     *  copy constructor.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_reference<int> ref = v[0];
+     *
+     *  // ref equals the object at v[0]
+     *  assert(ref == v[0]);
+     *
+     *  // the address of ref equals the address of v[0]
+     *  assert(&ref == &v[0]);
+     *
+     *  // modifying v[0] modifies ref
+     *  v[0] = 13;
+     *  assert(ref == 13);
+     *  \endcode
+     *
+     *  \note This constructor is templated primarily to allow initialization of
+     *  <tt>device_reference<const T></tt> from <tt>device_reference<T></tt>.
+     */
+    template<typename OtherT>
+    __host__ __device__
+    device_reference(const device_reference<OtherT> &other,
+                     typename thrust::detail::enable_if_convertible<
+                       typename device_reference<OtherT>::pointer,
+                       pointer
+                     >::type * = 0)
+      : super_t(other)
+    {}
+
+    /*! This copy constructor initializes this \p device_reference
+     *  to refer to an object pointed to by the given \p device_ptr. After
+     *  this \p device_reference is constructed, it shall refer to the
+     *  object pointed to by \p ptr.
+     *
+     *  \param ptr A \p device_ptr to copy from.
+     *
+     *  The following code snippet demonstrates the semantic of this
+     *  copy constructor.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals the object pointed to by ptr
+     *  assert(ref == *ptr);
+     *
+     *  // the address of ref equals ptr
+     *  assert(&ref == ptr);
+     *
+     *  // modifying *ptr modifies ref
+     *  *ptr = 13;
+     *  assert(ref == 13);
+     *  \endcode
+     */
+    __host__ __device__
+    explicit device_reference(const pointer &ptr)
+      : super_t(ptr)
+    {}
+
+    /*! This assignment operator assigns the value of the object referenced by
+     *  the given \p device_reference to the object referenced by this
+     *  \p device_reference.
+     *
+     *  \param other The \p device_reference to assign from.
+     *  \return <tt>*this</tt>
+     */
+    template<typename OtherT>
+    __host__ __device__
+    device_reference &operator=(const device_reference<OtherT> &other)
+    {
+      return super_t::operator=(other);
+    }
+
+    /*! Assignment operator assigns the value of the given value to the
+     *  value referenced by this \p device_reference.
+     *
+     *  \param x The value to assign from.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    device_reference &operator=(const value_type &x)
+    {
+      return super_t::operator=(x);
+    }
+
+// declare these members for the purpose of Doxygenating them
+// they actually exist in a derived-from class
+#if 0
+    /*! Address-of operator returns a \p device_ptr pointing to the object
+     *  referenced by this \p device_reference. It does not return the
+     *  address of this \p device_reference.
+     *
+     *  \return A \p device_ptr pointing to the object this
+     *  \p device_reference references.
+     */
+    __host__ __device__
+    pointer operator&(void) const;
+
+    /*! Conversion operator converts this \p device_reference to T
+     *  by returning a copy of the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return A copy of the object referenced by this \p device_reference.
+     */
+    __host__ __device__
+    operator value_type (void) const;
+
+    /*! swaps the value this \p device_reference references with another.
+     *  \p other The other \p device_reference with which to swap.
+     */
+    __host__ __device__
+    void swap(device_reference &other);
+
+    /*! Prefix increment operator increments the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return <tt>*this</tt>
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's prefix increment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // increment ref
+     *  ++ref;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The increment executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator++(void);
+
+    /*! Postfix increment operator copies the object referenced by this
+     *  \p device_reference, increments the object referenced by this
+     *  \p device_reference, and returns the copy.
+     *
+     *  \return A copy of the object referenced by this \p device_reference
+     *          before being incremented.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's postfix increment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // increment ref
+     *  int x = ref++;
+     *
+     *  // x equals 0
+     *  assert(x == 0)
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The increment executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    value_type operator++(int);
+
+    /*! Addition assignment operator add-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the add-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's addition assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // add-assign ref
+     *  ref += 5;
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *  \endcode
+     *
+     *  \note The add-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator+=(const T &rhs);
+
+    /*! Prefix decrement operator decrements the object referenced by this
+     *  \p device_reference.
+     *
+     *  \return <tt>*this</tt>
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's prefix decrement operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // decrement ref
+     *  --ref;
+     *
+     *  // ref equals -1
+     *  assert(ref == -1);
+     *
+     *  // the object pointed to by ptr equals -1
+     *  assert(*ptr == -1);
+     *
+     *  // v[0] equals -1
+     *  assert(v[0] == -1);
+     *  \endcode
+     *
+     *  \note The decrement executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator--(void);
+
+    /*! Postfix decrement operator copies the object referenced by this
+     *  \p device_reference, decrements the object referenced by this
+     *  \p device_reference, and returns the copy.
+     *
+     *  \return A copy of the object referenced by this \p device_reference
+     *          before being decremented.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's postfix decrement operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // decrement ref
+     *  int x = ref--;
+     *
+     *  // x equals 0
+     *  assert(x == 0)
+     *
+     *  // ref equals -1
+     *  assert(ref == -1);
+     *
+     *  // the object pointed to by ptr equals -1
+     *  assert(*ptr == -1);
+     *
+     *  // v[0] equals -1
+     *  assert(v[0] == -1);
+     *  \endcode
+     *
+     *  \note The decrement executes as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    value_type operator--(int);
+
+    /*! Subtraction assignment operator subtract-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the subtraction-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's addition assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // subtract-assign ref
+     *  ref -= 5;
+     *
+     *  // ref equals -5
+     *  assert(ref == -5);
+     *
+     *  // the object pointed to by ptr equals -5
+     *  assert(*ptr == -5);
+     *
+     *  // v[0] equals -5
+     *  assert(v[0] == -5);
+     *  \endcode
+     *
+     *  \note The subtract-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator-=(const T &rhs);
+
+    /*! Multiplication assignment operator multiply-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the multiply-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's multiply assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // multiply-assign ref
+     *  ref *= 5;
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *  \endcode
+     *
+     *  \note The multiply-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator*=(const T &rhs);
+
+    /*! Division assignment operator divide-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the divide-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's divide assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,5);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *
+     *  // divide-assign ref
+     *  ref /= 5;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The divide-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator/=(const T &rhs);
+
+    /*! Modulation assignment operator modulus-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the divide-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's divide assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,5);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 5
+     *  assert(ref == 5);
+     *
+     *  // the object pointed to by ptr equals 5
+     *  assert(*ptr == 5);
+     *
+     *  // v[0] equals 5
+     *  assert(v[0] == 5);
+     *
+     *  // modulus-assign ref
+     *  ref %= 5;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The modulus-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator%=(const T &rhs);
+
+    /*! Bitwise left shift assignment operator left shift-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the left shift-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's left shift assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // left shift-assign ref
+     *  ref <<= 1;
+     *
+     *  // ref equals 2
+     *  assert(ref == 2);
+     *
+     *  // the object pointed to by ptr equals 2
+     *  assert(*ptr == 2);
+     *
+     *  // v[0] equals 2
+     *  assert(v[0] == 2);
+     *  \endcode
+     *
+     *  \note The left shift-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator<<=(const T &rhs);
+
+    /*! Bitwise right shift assignment operator right shift-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the right shift-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's right shift assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,2);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 2
+     *  assert(ref == 2);
+     *
+     *  // the object pointed to by ptr equals 2
+     *  assert(*ptr == 2);
+     *
+     *  // v[0] equals 2
+     *  assert(v[0] == 2);
+     *
+     *  // right shift-assign ref
+     *  ref >>= 1;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The right shift-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator>>=(const T &rhs);
+
+    /*! Bitwise AND assignment operator AND-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the AND-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's AND assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // right AND-assign ref
+     *  ref &= 0;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The AND-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator&=(const T &rhs);
+
+    /*! Bitwise OR assignment operator OR-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the OR-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's OR assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,0);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *
+     *  // right OR-assign ref
+     *  ref |= 1;
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *  \endcode
+     *
+     *  \note The OR-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator|=(const T &rhs);
+
+    /*! Bitwise XOR assignment operator XOR-assigns the object referenced by this
+     *  \p device_reference and returns this \p device_reference.
+     *
+     *  \param rhs The right hand side of the XOR-assignment.
+     *  \return <tt>*this</tt>.
+     *
+     *  The following code snippet demonstrates the semantics of
+     *  \p device_reference's XOR assignment operator.
+     *
+     *  \code
+     *  #include <thrust/device_vector.h>
+     *  #include <assert.h>
+     *  ...
+     *  thrust::device_vector<int> v(1,1);
+     *  thrust::device_ptr<int> ptr = &v[0];
+     *  thrust::device_reference<int> ref(ptr);
+     *
+     *  // ref equals 1
+     *  assert(ref == 1);
+     *
+     *  // the object pointed to by ptr equals 1
+     *  assert(*ptr == 1);
+     *
+     *  // v[0] equals 1
+     *  assert(v[0] == 1);
+     *
+     *  // right XOR-assign ref
+     *  ref ^= 1;
+     *
+     *  // ref equals 0
+     *  assert(ref == 0);
+     *
+     *  // the object pointed to by ptr equals 0
+     *  assert(*ptr == 0);
+     *
+     *  // v[0] equals 0
+     *  assert(v[0] == 0);
+     *  \endcode
+     *
+     *  \note The XOR-assignment executes as as if it were executed on the host.
+     *  This may change in a later version.
+     */
+    device_reference &operator^=(const T &rhs);
+#endif // end doxygen-only members
+}; // end device_reference
+
+/*! swaps the value of one \p device_reference with another.
+ *  \p x The first \p device_reference of interest.
+ *  \p y The second \p device_reference of interest.
+ */
+template<typename T>
+__host__ __device__
+void swap(device_reference<T>& x, device_reference<T>& y)
+{
+  x.swap(y);
+}
+
+// declare these methods for the purpose of Doxygenating them
+// they actually are defined for a derived-from class
+#if THRUST_DOXYGEN
+/*! Writes to an output stream the value of a \p device_reference.
+ *
+ *  \param os The output stream.
+ *  \param y The \p device_reference to output.
+ *  \return os.
+ */
+template<typename T, typename charT, typename traits>
+std::basic_ostream<charT, traits> &
+operator<<(std::basic_ostream<charT, traits> &os, const device_reference<T> &y);
+#endif
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_vector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b97e8d70335231e05891edd1a5bed05f96bdf25
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/device_vector.h
@@ -0,0 +1,511 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file
+ *  \brief A dynamically-sizable array of elements which resides in memory
+ *         accessible to devices.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/vector_base.h>
+#include <thrust/device_allocator.h>
+
+#include <initializer_list>
+#include <vector>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup containers Containers
+ *  \{
+ */
+
+/*! A \p device_vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p device_vector may vary dynamically; memory management is
+ *  automatic. The memory associated with a \p device_vector resides in the
+ *  memory accessible to devices.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see device_allocator
+ *  \see host_vector
+ *  \see universal_vector
+ */
+template<typename T, typename Alloc = thrust::device_allocator<T> >
+  class device_vector
+    : public detail::vector_base<T,Alloc>
+{
+  private:
+    typedef detail::vector_base<T,Alloc> Parent;
+
+  public:
+    /*! \cond
+     */
+    typedef typename Parent::size_type  size_type;
+    typedef typename Parent::value_type value_type;
+    /*! \endcond
+     */
+
+    /*! This constructor creates an empty \p device_vector.
+     */
+    device_vector(void)
+      :Parent() {}
+
+    /*! This constructor creates an empty \p device_vector.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    device_vector(const Alloc &alloc)
+      :Parent(alloc) {}
+
+    /*! The destructor erases the elements.
+     */
+    //  Define an empty destructor to explicitly specify
+    //  its execution space qualifier, as a workaround for nvcc warning
+    ~device_vector(void) {}
+
+    /*! This constructor creates a \p device_vector with the given
+     *  size.
+     *  \param n The number of elements to initially create.
+     */
+    explicit device_vector(size_type n)
+      :Parent(n) {}
+
+    /*! This constructor creates a \p device_vector with the given
+     *  size.
+     *  \param n The number of elements to initially create.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    explicit device_vector(size_type n, const Alloc &alloc)
+      :Parent(n,alloc) {}
+
+    /*! This constructor creates a \p device_vector with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     */
+    explicit device_vector(size_type n, const value_type &value)
+      :Parent(n,value) {}
+
+    /*! This constructor creates a \p device_vector with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    explicit device_vector(size_type n, const value_type &value, const Alloc &alloc)
+      :Parent(n,value,alloc) {}
+
+    /*! Copy constructor copies from an exemplar \p device_vector.
+     *  \param v The \p device_vector to copy.
+     */
+    device_vector(const device_vector &v)
+      :Parent(v) {}
+
+    /*! Copy constructor copies from an exemplar \p device_vector.
+     *  \param v The \p device_vector to copy.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    device_vector(const device_vector &v, const Alloc &alloc)
+      :Parent(v,alloc) {}
+
+  #if THRUST_CPP_DIALECT >= 2011
+    /*! Move constructor moves from another \p device_vector.
+     *  \param v The device_vector to move.
+     */
+    device_vector(device_vector &&v)
+      :Parent(std::move(v)) {}
+
+    /*! Move constructor moves from another \p device_vector.
+     *  \param v The device_vector to move.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    device_vector(device_vector &&v, const Alloc &alloc)
+      :Parent(std::move(v), alloc) {}
+  #endif // THRUST_CPP_DIALECT >= 2011
+
+    /*! Copy assign operator copies another \p device_vector with the same type.
+     *  \param v The \p device_vector to copy.
+     */
+    device_vector &operator=(const device_vector &v)
+    { Parent::operator=(v); return *this; }
+
+  #if THRUST_CPP_DIALECT >= 2011
+    /*! Move assign operator moves from another \p device_vector.
+     *  \param v The device_vector to move.
+     */
+     device_vector &operator=(device_vector &&v)
+     { Parent::operator=(std::move(v)); return *this; }
+  #endif // THRUST_CPP_DIALECT >= 2011
+
+    /*! Copy constructor copies from an exemplar \p device_vector with different type.
+     *  \param v The \p device_vector to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    explicit device_vector(const device_vector<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign operator copies from an exemplar \p device_vector with different type.
+     *  \param v The \p device_vector to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    device_vector &operator=(const device_vector<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this; }
+
+    /*! Copy constructor copies from an exemplar \c std::vector.
+     *  \param v The <tt>std::vector</tt> to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    device_vector(const std::vector<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign operator copies from an exemplar <tt>std::vector</tt>.
+     *  \param v The <tt>std::vector</tt> to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    device_vector &operator=(const std::vector<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this;}
+
+    /*! Copy construct from a \p vector_base whose element type is convertible
+     *  to \c T.
+     *
+     *  \param v The \p vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    device_vector(const detail::vector_base<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign a \p vector_base whose element type is convertible to \c T.
+     *  \param v The \p vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    device_vector &operator=(const detail::vector_base<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this; }
+
+    /*! This constructor builds a \p device_vector from an intializer_list.
+     *  \param il The intializer_list.
+     */
+    device_vector(std::initializer_list<T> il)
+      :Parent(il) {}
+      
+    /*! This constructor builds a \p device_vector from an intializer_list.
+     *  \param il The intializer_list.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    device_vector(std::initializer_list<T> il, const Alloc &alloc)
+      :Parent(il, alloc) {}
+      
+    /*! Assign an \p intializer_list with a matching element type
+     *  \param il The intializer_list.
+     */
+    device_vector &operator=(std::initializer_list<T> il)
+    { Parent::operator=(il); return *this; }
+
+    /*! This constructor builds a \p device_vector from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     */
+    template<typename InputIterator>
+    device_vector(InputIterator first, InputIterator last)
+      :Parent(first,last) {}
+
+    /*! This constructor builds a \p device_vector from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     *  \param alloc The allocator to use by this device_vector.
+     */
+    template<typename InputIterator>
+    device_vector(InputIterator first, InputIterator last, const Alloc &alloc)
+      :Parent(first,last,alloc) {}
+
+// declare these members for the purpose of Doxygenating them
+// they actually exist in a derived-from class
+#if 0
+    /*! \brief Resizes this vector to the specified number of elements.
+     *  \param new_size Number of elements this vector should contain.
+     *  \param x Data with which new elements should be populated.
+     *  \throw std::length_error If n exceeds max_size().
+     *
+     *  This method will resize this vector to the specified number of
+     *  elements.  If the number is smaller than this vector's current
+     *  size this vector is truncated, otherwise this vector is
+     *  extended and new elements are populated with given data.
+     */
+    void resize(size_type new_size, const value_type &x = value_type());
+
+    /*! Returns the number of elements in this vector.
+     */
+    size_type size(void) const;
+
+    /*! Returns the size() of the largest possible vector.
+     *  \return The largest possible return value of size().
+     */
+    size_type max_size(void) const;
+
+    /*! \brief If n is less than or equal to capacity(), this call has no effect.
+     *         Otherwise, this method is a request for allocation of additional memory. If
+     *         the request is successful, then capacity() is greater than or equal to
+     *         n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+     *  \throw std::length_error If n exceeds max_size().
+     */
+    void reserve(size_type n);
+
+    /*! Returns the number of elements which have been reserved in this
+     *  vector.
+     */
+    size_type capacity(void) const;
+
+    /*! This method shrinks the capacity of this vector to exactly
+     *  fit its elements.
+     */
+    void shrink_to_fit(void);
+
+    /*! \brief Subscript access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read/write reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    reference operator[](size_type n);
+
+    /*! \brief Subscript read access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    const_reference operator[](size_type n) const;
+
+    /*! This method returns an iterator pointing to the beginning of
+     *  this vector.
+     *  \return mStart
+     */
+    iterator begin(void);
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator begin(void) const;
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator cbegin(void) const;
+
+    /*! This method returns a reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    reverse_iterator rbegin(void);
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator rbegin(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator crbegin(void) const;
+
+    /*! This method returns an iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    iterator end(void);
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator end(void) const;
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator cend(void) const;
+
+    /*! This method returns a reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    reverse_iterator rend(void);
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator rend(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator crend(void) const;
+
+    /*! This method returns a const_reference referring to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    const_reference front(void) const;
+
+    /*! This method returns a reference pointing to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    reference front(void);
+
+    /*! This method returns a const reference pointing to the last element of
+     *  this vector.
+     *  \return The last element of this vector.
+     */
+    const_reference back(void) const;
+
+    /*! This method returns a reference referring to the last element of
+     *  this vector_dev.
+     *  \return The last element of this vector.
+     */
+    reference back(void);
+
+    /*! This method returns a pointer to this vector's first element.
+     *  \return A pointer to the first element of this vector.
+     */
+    pointer data(void);
+
+    /*! This method returns a const_pointer to this vector's first element.
+     *  \return a const_pointer to the first element of this vector.
+     */
+    const_pointer data(void) const;
+
+    /*! This method resizes this vector to 0.
+     */
+    void clear(void);
+
+    /*! This method returns true iff size() == 0.
+     *  \return true if size() == 0; false, otherwise.
+     */
+    bool empty(void) const;
+
+    /*! This method appends the given element to the end of this vector.
+     *  \param x The element to append.
+     */
+    void push_back(const value_type &x);
+
+    /*! This method erases the last element of this vector, invalidating
+     *  all iterators and references to it.
+     */
+    void pop_back(void);
+
+    /*! This method swaps the contents of this device_vector with another vector.
+     *  \param v The vector with which to swap.
+     */
+    void swap(device_vector &v);
+
+    /*! This method removes the element at position pos.
+     *  \param pos The position of the element of interest.
+     *  \return An iterator pointing to the new location of the element that followed the element
+     *          at position pos.
+     */
+    iterator erase(iterator pos);
+
+    /*! This method removes the range of elements [first,last) from this vector.
+     *  \param first The beginning of the range of elements to remove.
+     *  \param last The end of the range of elements to remove.
+     *  \return An iterator pointing to the new location of the element that followed the last
+     *          element in the sequence [first,last).
+     */
+    iterator erase(iterator first, iterator last);
+
+    /*! This method inserts a single copy of a given exemplar value at the
+     *  specified position in this vector.
+     *  \param position The insertion position.
+     *  \param x The exemplar element to copy & insert.
+     *  \return An iterator pointing to the newly inserted element.
+     */
+    iterator insert(iterator position, const T &x);
+
+    /*! This method inserts a copy of an exemplar value to a range at the
+     *  specified position in this vector.
+     *  \param position The insertion position
+     *  \param n The number of insertions to perform.
+     *  \param x The value to replicate and insert.
+     */
+    void insert(iterator position, size_type n, const T &x);
+
+    /*! This method inserts a copy of an input range at the specified position
+     *  in this vector.
+     *  \param position The insertion position.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator>Input Iterator</a>,
+     *                        and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>.
+     */
+    template<typename InputIterator>
+    void insert(iterator position, InputIterator first, InputIterator last);
+
+    /*! This version of \p assign replicates a given exemplar
+     *  \p n times into this vector.
+     *  \param n The number of times to copy \p x.
+     *  \param x The exemplar element to replicate.
+     */
+    void assign(size_type n, const T &x);
+
+    /*! This version of \p assign makes this vector a copy of a given input range.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>.
+     */
+    template<typename InputIterator>
+    void assign(InputIterator first, InputIterator last);
+
+    /*! This method returns a copy of this vector's allocator.
+     *  \return A copy of the alloctor used by this vector.
+     */
+    allocator_type get_allocator(void) const;
+#endif // end doxygen-only members
+};
+
+/*! Exchanges the values of two vectors.
+ *  \p x The first \p device_vector of interest.
+ *  \p y The second \p device_vector of interest.
+ */
+template<typename T, typename Alloc>
+  void swap(device_vector<T,Alloc> &a, device_vector<T,Alloc> &b)
+{
+  a.swap(b);
+}
+
+/*! \} // containres
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/distance.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/distance.h
new file mode 100644
index 0000000000000000000000000000000000000000..890879115126100eac96dea34e9b470211303ca5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/distance.h
@@ -0,0 +1,74 @@
+/*
+ *  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 distance.h
+ *  \brief Computes the size of a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \p distance finds the distance between \p first and \p last, i.e. the
+ *  number of times that \p first must be incremented until it is equal to
+ *  \p last.
+ *
+ *  \param first The beginning of an input range of interest.
+ *  \param last The end of an input range of interest.
+ *  \return The distance between the beginning and end of the input range.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *
+ *  \pre If \c InputIterator meets the requirements of random access iterator, \p last shall be reachable from \p first or
+ *       \p first shall be reachable from \p last; otherwise, \p last shall be reachable from \p first.
+ *
+ *  The following code snippet demonstrates how to use \p distance to compute
+ *  the distance to one iterator from another.
+ *
+ *  \code
+ *  #include <thrust/distance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator iter1 = vec.begin();
+ *  thrust::device_vector<int>::iterator iter2 = iter1 + 7;
+ *
+ *  int d = thrust::distance(iter1, iter2);
+ *
+ *  // d is 7
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/distance
+ */
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last);
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/distance.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/equal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/equal.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f3518907895e7baefbef4e873895bd40306b504
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/equal.h
@@ -0,0 +1,235 @@
+/*
+ *  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 equal.h
+ *  \brief Equality between ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup comparisons
+ *  \ingroup reductions
+ *  \{
+ */
+
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>, <tt>*i == *(first2 + (i - first1))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and \p InputIterator1's \c value_type can be compared for equality with \c InputIterator2's \c value_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and \p InputIterator2's \c value_type can be compared for equality with \c InputIterator1's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p equal to test
+ *  two ranges for equality using the \p thrust::host execution policy:
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {3, 1, 4, 1, 5, 9, 3};
+ *  int A2[7] = {3, 1, 4, 2, 8, 5, 7};
+ *  ...
+ *  bool result = thrust::equal(thrust::host, A1, A1 + 7, A2);
+ *
+ *  // result == false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+bool equal(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
+
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>, <tt>*i == *(first2 + (i - first1))</tt>.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and \p InputIterator1's \c value_type can be compared for equality with \c InputIterator2's \c value_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and \p InputIterator2's \c value_type can be compared for equality with \c InputIterator1's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p equal to test
+ *  two ranges for equality.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  ...
+ *  int A1[7] = {3, 1, 4, 1, 5, 9, 3};
+ *  int A2[7] = {3, 1, 4, 2, 8, 5, 7};
+ *  ...
+ *  bool result = thrust::equal(A1, A1 + 7, A2);
+ *
+ *  // result == false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename InputIterator1, typename InputIterator2>
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2);
+
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>,
+ *  <tt>binary_pred(*i, *(first2 + (i - first1)))</tt> is \c true.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param binary_pred Binary predicate used to test element equality.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal to compare the
+ *  elements in two ranges modulo 2 using the \p thrust::host execution policy.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  struct compare_modulo_two
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x, int y) const
+ *    {
+ *      return (x % 2) == (y % 2);
+ *    }
+ *  };
+ *  ...
+ *  int x[6] = {0, 2, 4, 6, 8, 10};
+ *  int y[6] = {1, 3, 5, 7, 9, 11};
+ *
+ *  bool result = thrust::equal(x, x + 6, y, compare_modulo_two());
+ *
+ *  // result is false
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+bool equal(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);
+
+
+/*! \p equal returns \c true if the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> are identical when
+ *  compared element-by-element, and otherwise returns \c false.
+ *
+ *  This version of \p equal returns \c true if and only if for every
+ *  iterator \c i in <tt>[first1, last1)</tt>,
+ *  <tt>binary_pred(*i, *(first2 + (i - first1)))</tt> is \c true.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param binary_pred Binary predicate used to test element equality.
+ *  \return \c true, if the sequences are equal; \c false, otherwise.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p equal to compare the
+ *  elements in two ranges modulo 2.
+ *
+ *  \code
+ *  #include <thrust/equal.h>
+ *  
+ *  struct compare_modulo_two
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x, int y) const
+ *    {
+ *      return (x % 2) == (y % 2);
+ *    }
+ *  };
+ *  ...
+ *  int x[6] = {0, 2, 4, 6, 8, 10};
+ *  int y[6] = {1, 3, 5, 7, 9, 11};
+ *
+ *  bool result = thrust::equal(x, x + 5, y, compare_modulo_two());
+ *
+ *  // result is true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/equal
+ */
+template <typename InputIterator1, typename InputIterator2, 
+          typename BinaryPredicate>
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2, BinaryPredicate binary_pred);
+
+
+/*! \} // end comparisons
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/equal.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/event.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/event.h
new file mode 100644
index 0000000000000000000000000000000000000000..75578d96443c2e20c0b80b4d4efe28a6a5a5b04f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/event.h
@@ -0,0 +1,26 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/event.h
+ *  \brief `thrust::event`, an asynchronous handle type.
+ */
+
+#pragma once
+
+#include <thrust/future.h>
+
+// TODO: Actually separate `<thrust/future.h>` into two headers.
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..ecf14413f604ad19c3904d341f467e86b4fbcf7a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/execution_policy.h
@@ -0,0 +1,392 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/execution_policy.h
+ *  \brief Thrust execution policies.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/execute_with_allocator.h>
+#include <thrust/detail/seq.h>
+
+//! \cond
+
+// #include the host system's execution_policy header
+#define __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER <__THRUST_HOST_SYSTEM_ROOT/execution_policy.h>
+#include __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER
+#undef __THRUST_HOST_SYSTEM_EXECUTION_POLICY_HEADER
+
+// #include the device system's execution_policy.h header
+#define __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/execution_policy.h>
+#include __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EXECUTION_POLICY_HEADER
+
+//! \endcond
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \cond
+ */
+
+
+namespace detail
+{
+
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::detail::par_t host_t;
+
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::detail::par_t device_t;
+
+
+} // end detail
+
+
+/*! \endcond
+ */
+
+
+/*! \addtogroup execution_policies Parallel Execution Policies
+ *  \{
+ */
+
+
+// define execution_policy for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p execution_policy is the base class for all Thrust parallel execution policies
+ *  like \p thrust::host, \p thrust::device, and each backend system's tag type.
+ *
+ *  Custom user-defined backends should derive a policy from this type in order to
+ *  interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy
+ *  from \p thrust::execution_policy to implement a backend which only implements \p for_each:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // can't dispatch thrust::transform because no overload exists for my_policy:
+ *    //thrust::transform(exec, data, data, + 4, data, thrust::identity<int>()); // error!
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see device_execution_policy
+ */
+template<typename DerivedPolicy>
+struct execution_policy : thrust::detail::execution_policy_base<DerivedPolicy>
+{};
+#endif
+
+
+/*! \p host_execution_policy is the base class for all Thrust parallel execution policies
+ *  which are derived from Thrust's default host backend system configured with the \p THRUST_HOST_SYSTEM
+ *  macro.
+ *
+ *  Custom user-defined backends which wish to inherit the functionality of Thrust's host backend system
+ *  should derive a policy from this type in order to interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy from
+ *  \p thrust::host_execution_policy to implement a backend which specializes \p for_each while inheriting
+ *  the behavior of every other algorithm from the host system:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::host_execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::host_execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // dispatch thrust::transform whose behavior our policy inherits
+ *    thrust::transform(exec, data, data, + 4, data, thrust::identity<int>());
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see execution_policy
+ *  \see device_execution_policy
+ */
+template<typename DerivedPolicy>
+  struct host_execution_policy
+    : thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::execution_policy<DerivedPolicy>
+{};
+
+
+/*! \p device_execution_policy is the base class for all Thrust parallel execution policies
+ *  which are derived from Thrust's default device backend system configured with the \p THRUST_DEVICE_SYSTEM
+ *  macro.
+ *
+ *  Custom user-defined backends which wish to inherit the functionality of Thrust's device backend system
+ *  should derive a policy from this type in order to interoperate with Thrust algorithm dispatch.
+ *
+ *  The following code snippet demonstrates how to derive a standalone custom execution policy from
+ *  \p thrust::device_execution_policy to implement a backend which specializes \p for_each while inheriting
+ *  the behavior of every other algorithm from the device system:
+ *
+ *  \code
+ *  #include <thrust/execution_policy.h>
+ *  #include <iostream>
+ *
+ *  // define a type derived from thrust::device_execution_policy to distinguish our custom execution policy:
+ *  struct my_policy : thrust::device_execution_policy<my_policy> {};
+ *
+ *  // overload for_each on my_policy
+ *  template<typename Iterator, typename Function>
+ *  Iterator for_each(my_policy, Iterator first, Iterator last, Function f)
+ *  {
+ *    std::cout << "Hello, world from for_each(my_policy)!" << std::endl;
+ *
+ *    for(; first < last; ++first)
+ *    {
+ *      f(*first);
+ *    }
+ *
+ *    return first;
+ *  }
+ *
+ *  struct ignore_argument
+ *  {
+ *    void operator()(int) {}
+ *  };
+ *
+ *  int main()
+ *  {
+ *    int data[4];
+ *
+ *    // dispatch thrust::for_each using our custom policy:
+ *    my_policy exec;
+ *    thrust::for_each(exec, data, data + 4, ignore_argument());
+ *
+ *    // dispatch thrust::transform whose behavior our policy inherits
+ *    thrust::transform(exec, data, data, + 4, data, thrust::identity<int>());
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see execution_policy
+ *  \see host_execution_policy
+ */
+template<typename DerivedPolicy>
+  struct device_execution_policy
+    : thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::execution_policy<DerivedPolicy>
+{};
+
+
+/*! \p thrust::host is the default parallel execution policy associated with Thrust's host backend system
+ *  configured by the \p THRUST_HOST_SYSTEM macro.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may directly target
+ *  algorithm dispatch at Thrust's host system by providing \p thrust::host as an algorithm parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such as
+ *  \p thrust::host_vector.
+ *
+ *  Note that even though \p thrust::host targets the host CPU, it is a parallel execution policy. That is,
+ *  the order that an algorithm invokes functors or dereferences iterators is not defined.
+ *
+ *  The type of \p thrust::host is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::host to explicitly dispatch an invocation
+ *  of \p thrust::for_each to the host backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  int vec[] = { 0, 1, 2 };
+ *
+ *  thrust::for_each(thrust::host, vec, vec + 3, printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see thrust::device
+ */
+static const detail::host_t host;
+
+
+/*! \p thrust::device is the default parallel execution policy associated with Thrust's device backend system
+ *  configured by the \p THRUST_DEVICE_SYSTEM macro.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may directly target
+ *  algorithm dispatch at Thrust's device system by providing \p thrust::device as an algorithm parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such as
+ *  \p thrust::device_vector or to avoid wrapping e.g. raw pointers allocated by the CUDA API with types
+ *  such as \p thrust::device_ptr.
+ *
+ *  The user must take care to guarantee that the iterators provided to an algorithm are compatible with
+ *  the device backend system. For example, raw pointers allocated by <tt>std::malloc</tt> typically
+ *  cannot be dereferenced by a GPU. For this reason, raw pointers allocated by host APIs should not be mixed
+ *  with a \p thrust::device algorithm invocation when the device backend is CUDA.
+ *
+ *  The type of \p thrust::device is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::device to explicitly dispatch an invocation
+ *  of \p thrust::for_each to the device backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> vec(3);
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::device, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see host_execution_policy
+ *  \see thrust::device
+ */
+THRUST_INLINE_CONSTANT detail::device_t device;
+
+
+// define seq for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p thrust::seq is an execution policy which requires an algorithm invocation to execute sequentially
+ *  in the current thread. It can not be configured by a compile-time macro.
+ *
+ *  The type of \p thrust::seq is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::seq to explicitly execute an invocation
+ *  of \p thrust::for_each sequentially:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <vector>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  std::vector<int> vec(3);
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::seq, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in sequential order
+ *  \endcode
+ *
+ *  \see thrust::host
+ *  \see thrust::device
+ */
+static const detail::seq_t seq;
+#endif
+
+
+/*! \}
+ */
+
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/extrema.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/extrema.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca419a0aa5bd8282cadf9d13a4c7161bf0a781d6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/extrema.h
@@ -0,0 +1,801 @@
+/*
+ *  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 extrema.h
+ *  \brief Functions for computing computing extremal values
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! This version of \p min returns the smaller of two values, given a comparison operation.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \param comp A comparison operation.
+ *  \return The smaller element.
+ *
+ *  \tparam T is convertible to \p BinaryPredicate's first argument type and to its second argument type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min to compute the smaller of two
+ *  key-value objects.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value a = {13, 0};
+ *  key_value b = { 7, 1);
+ *
+ *  key_value smaller = thrust::min(a, b, compare_key_value());
+ *
+ *  // smaller is {7, 1}
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see max
+ */
+template<typename T, typename BinaryPredicate>
+__host__ __device__
+  T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp);
+
+
+/*! This version of \p min returns the smaller of two values.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \return The smaller element.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min to compute the smaller of two
+ *  integers.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int a = 13;
+ *  int b = 7;
+ *
+ *  int smaller = thrust::min(a, b);
+ *
+ *  // smaller is 7
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see max
+ */
+template<typename T>
+__host__ __device__
+  T min THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs);
+
+
+/*! This version of \p max returns the larger of two values, given a comparison operation.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \param comp A comparison operation.
+ *  \return The larger element.
+ *
+ *  \tparam T is convertible to \p BinaryPredicate's first argument type and to its second argument type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">BinaryPredicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max to compute the larger of two
+ *  key-value objects.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value a = {13, 0};
+ *  key_value b = { 7, 1);
+ *
+ *  key_value larger = thrust::max(a, b, compare_key_value());
+ *
+ *  // larger is {13, 0}
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see min
+ */
+template<typename T, typename BinaryPredicate>
+__host__ __device__
+  T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs, BinaryPredicate comp);
+
+
+/*! This version of \p max returns the larger of two values.
+ *  \param lhs The first value to compare.
+ *  \param rhs The second value to compare.
+ *  \return The larger element.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max to compute the larger of two
+ *  integers.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int a = 13;
+ *  int b = 7;
+ *
+ *  int larger = thrust::min(a, b);
+ *
+ *  // larger is 13
+ *  \endcode
+ *
+ *  \note Returns the first argument when the arguments are equivalent.
+ *  \see min
+ */
+template<typename T>
+__host__ __device__
+  T max THRUST_PREVENT_MACRO_SUBSTITUTION (const T &lhs, const T &rhs);
+
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup extrema
+ *  \ingroup reductions
+ *  \{
+ */
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*j < *i</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::min_element(thrust::host, data, data + 6);
+ *
+ *  // result is data + 1
+ *  // *result is 0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element 
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator min_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last);
+
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*j < *i</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::min_element(data, data + 6);
+ *
+ *  // result is data + 1
+ *  // *result is 0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element 
+ */
+template <typename ForwardIterator>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
+
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*j, *i)</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min_element to find the smallest element
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *smallest = thrust::min_element(thrust::host, data, data + 4, compare_key_value());
+ *
+ *  // smallest == data + 1
+ *  // *smallest == {0,7}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element 
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator min_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+
+/*! \p min_element finds the smallest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value smaller
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p min_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p min_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*j, *i)</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the smallest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p min_element to find the smallest element
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *smallest = thrust::min_element(data, data + 4, compare_key_value());
+ *
+ *  // smallest == data + 1
+ *  // *smallest == {0,7}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/min_element 
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
+                            BinaryPredicate comp);
+
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  greater than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*i < *j</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam A Thrust backend system.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::max_element(thrust::host, data, data + 6);
+ *
+ *  // *result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element 
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator max_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last);
+
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  greater than another. This version compares objects using \c operator<. Specifically,
+ *  this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>*i < *j</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int *result = thrust::max_element(data, data + 6);
+ *
+ *  // *result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element 
+ */
+template <typename ForwardIterator>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
+
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*i, *j)</tt> is
+ *  \c false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max_element to find the largest element
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *largest = thrust::max_element(thrust::host, data, data + 4, compare_key_value());
+ *
+ *  // largest == data + 3
+ *  // *largest == {6,1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element 
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator max_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+
+/*! \p max_element finds the largest element in the range <tt>[first, last)</tt>.
+ *  It returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that no other iterator in <tt>[first, last)</tt> points to a value larger
+ *  than \c *i. The return value is \p last if and only if <tt>[first, last)</tt> is an
+ *  empty range.
+ *
+ *  The two versions of \p max_element differ in how they define whether one element is
+ *  less than another. This version compares objects using a function object \p comp.
+ *  Specifically, this version of \p max_element returns the first iterator \c i in <tt>[first, last)</tt>
+ *  such that, for every iterator \c j in <tt>[first, last)</tt>, <tt>comp(*i, *j)</tt> is
+ *  \c false.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return An iterator pointing to the largest element of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p max_element to find the largest element
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  key_value *largest = thrust::max_element(data, data + 4, compare_key_value());
+ *
+ *  // largest == data + 3
+ *  // *largest == {6,1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/max_element 
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
+                            BinaryPredicate comp);
+
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  thrust::pair<int *, int *> result = thrust::minmax_element(thrust::host, data, data + 6);
+ *
+ *  // result.first is data + 1
+ *  // result.second is data + 5
+ *  // *result.first is 0
+ *  // *result.second is 3
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last);
+
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \c ForwardIterator's \c value_type is a model of
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  thrust::pair<int *, int *> result = thrust::minmax_element(data, data + 6);
+ *
+ *  // result.first is data + 1
+ *  // result.second is data + 5
+ *  // *result.first is 0
+ *  // *result.second is 3
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename ForwardIterator>
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(ForwardIterator first, 
+                                                             ForwardIterator last);
+
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p minmax_element to find the smallest and largest elements
+ *  of a collection of key-value pairs using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/pair.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(thrust::host, data, data + 4, compare_key_value());
+ *
+ *  // extrema.first   == data + 1
+ *  // *extrema.first  == {0,7}
+ *  // extrema.second  == data + 3
+ *  // *extrema.second == {6,1}
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp);
+
+
+/*! \p minmax_element finds the smallest and largest elements in the range <tt>[first, last)</tt>.
+ *  It returns a pair of iterators <tt>(imin, imax)</tt> where \c imin is the same iterator
+ *  returned by \p min_element and \c imax is the same iterator returned by \p max_element.
+ *  This function is potentially more efficient than separate calls to \p min_element and \p max_element.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp A binary predicate used for comparison.
+ *  \return A pair of iterator pointing to the smallest and largest elements of the range <tt>[first, last)</tt>,
+ *          if it is not an empty range; \p last, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \p comp's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p minmax_element to find the smallest and largest elements
+ *  of a collection of key-value pairs.
+ *
+ *  \code
+ *  #include <thrust/extrema.h>
+ *  #include <thrust/pair.h>
+ *
+ *  struct key_value
+ *  {
+ *    int key;
+ *    int value;
+ *  };
+ *
+ *  struct compare_key_value
+ *  {
+ *    __host__ __device__
+ *    bool operator()(key_value lhs, key_value rhs)
+ *    {
+ *      return lhs.key < rhs.key;
+ *    }
+ *  };
+ *
+ *  ...
+ *  key_value data[4] = { {4,5}, {0,7}, {2,3}, {6,1} };
+ *
+ *  thrust::pair<key_value*,key_value*> extrema = thrust::minmax_element(data, data + 4, compare_key_value());
+ *
+ *  // extrema.first   == data + 1
+ *  // *extrema.first  == {0,7}
+ *  // extrema.second  == data + 3
+ *  // *extrema.second == {6,1}
+ *  \endcode
+ *
+ *  \see min_element
+ *  \see max_element
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1840.pdf
+ */
+template <typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(ForwardIterator first, 
+                                                             ForwardIterator last,
+                                                             BinaryPredicate comp);
+
+/*! \} // end extrema
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/extrema.inl>
+#include <thrust/detail/minmax.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd9e40268972d7d03f7860ad8771d54f0c8a29e7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/fill.h
@@ -0,0 +1,206 @@
+/*
+ *  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 fill.h
+ *  \brief Fills a range with a constant value
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \addtogroup filling
+ *  \ingroup transformations
+ *  \{
+ */
+
+
+/*! \p fill assigns the value \p value to every element in
+ *  the range <tt>[first, last)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, last)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be copied.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T's \c value_type is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill(thrust::device, v.begin(), v.end(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill
+ *  \see \c fill_n
+ *  \see \c uninitialized_fill
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T &value);
+
+
+/*! \p fill assigns the value \p value to every element in
+ *  the range <tt>[first, last)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, last)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param value The value to be copied.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T's \c value_type is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value.
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill(v.begin(), v.end(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill
+ *  \see \c fill_n
+ *  \see \c uninitialized_fill
+ */
+template<typename ForwardIterator, typename T>
+__host__ __device__
+  void fill(ForwardIterator first,
+            ForwardIterator last,
+            const T &value);
+
+
+/*! \p fill_n assigns the value \p value to every element in
+ *  the range <tt>[first, first+n)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, first+n)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the sequence.
+ *  \param value The value to be copied.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T's \c value_type is convertible to a type in \p OutputIterator's set of \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill_n(thrust::device, v.begin(), v.size(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_fill_n
+ */
+template<typename DerivedPolicy, typename OutputIterator, typename Size, typename T>
+__host__ __device__
+  OutputIterator fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        OutputIterator first,
+                        Size n,
+                        const T &value);
+
+
+/*! \p fill_n assigns the value \p value to every element in
+ *  the range <tt>[first, first+n)</tt>. That is, for every
+ *  iterator \c i in <tt>[first, first+n)</tt>, it performs
+ *  the assignment <tt>*i = value</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the sequence.
+ *  \param value The value to be copied.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T's \c value_type is convertible to a type in \p OutputIterator's set of \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p fill to set a thrust::device_vector's
+ *  elements to a given value.
+ *
+ *  \code
+ *  #include <thrust/fill.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v(4);
+ *  thrust::fill_n(v.begin(), v.size(), 137);
+ *
+ *  // v[0] == 137, v[1] == 137, v[2] == 137, v[3] == 137
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_fill_n
+ */
+template<typename OutputIterator, typename Size, typename T>
+__host__ __device__
+  OutputIterator fill_n(OutputIterator first,
+                        Size n,
+                        const T &value);
+
+
+/*! \} // end filling
+ *  \} // transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/fill.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/find.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/find.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ab9b0a2df8f318198e45d84ed6b0416eb73ae1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/find.h
@@ -0,0 +1,381 @@
+/*
+ *  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 find.h
+ *  \brief Locating values in (unsorted) ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup searching
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p find returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>
+ *  or \c last if no such iterator exists.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param value The value to find.
+ *  \return The first iterator \c i such that <tt>*i == value</tt> or \c last.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \p InputIterator's \c value_type is equality comparable to type \c T.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">EqualityComparable</a>. 
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find(thrust::device, input.begin(), input.end(), 3); // returns input.first() + 2
+ *  iter = thrust::find(thrust::device, input.begin(), input.end(), 5); // returns input.first() + 1
+ *  iter = thrust::find(thrust::device, input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see find_if
+ *  \see mismatch
+ */
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+InputIterator find(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   const T& value);
+
+
+/*! \p find returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>*i == value</tt>
+ *  or \c last if no such iterator exists.
+ *
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param value The value to find.
+ *  \return The first iterator \c i such that <tt>*i == value</tt> or \c last.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \p InputIterator's \c value_type is equality comparable to type \c T.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">EqualityComparable</a>. 
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find(input.begin(), input.end(), 3); // returns input.first() + 2
+ *  iter = thrust::find(input.begin(), input.end(), 5); // returns input.first() + 1
+ *  iter = thrust::find(input.begin(), input.end(), 9); // returns input.end()
+ *  \endcode
+ *
+ *  \see find_if
+ *  \see mismatch
+ */
+template <typename InputIterator, typename T>
+InputIterator find(InputIterator first,
+                   InputIterator last,
+                   const T& value);
+
+
+/*! \p find_if returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true
+ *  or \c last if no such iterator exists.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param pred A predicate used to test range elements.
+ *  \return The first iterator \c i such that <tt>pred(*i)</tt> is \c true, or \c last.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct greater_than_four
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 4;
+ *    }
+ *  };
+ *
+ *  struct greater_than_ten
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 10;
+ *    }
+ *  };
+ *
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find_if(thrust::device, input.begin(), input.end(), greater_than_four()); // returns input.first() + 1
+ *
+ *  iter = thrust::find_if(thrust::device, input.begin(), input.end(), greater_than_ten());  // returns input.end()
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if_not
+ *  \see mismatch
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+/*! \p find_if returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true
+ *  or \c last if no such iterator exists.
+ *
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param pred A predicate used to test range elements.
+ *  \return The first iterator \c i such that <tt>pred(*i)</tt> is \c true, or \c last.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct greater_than_four
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 4;
+ *    }
+ *  };
+ *
+ *  struct greater_than_ten
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 10;
+ *    }
+ *  };
+ *
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find_if(input.begin(), input.end(), greater_than_four()); // returns input.first() + 1
+ *
+ *  iter = thrust::find_if(input.begin(), input.end(), greater_than_ten());  // returns input.end()
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if_not
+ *  \see mismatch
+ */
+template <typename InputIterator, typename Predicate>
+InputIterator find_if(InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+/*! \p find_if_not returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c false
+ *  or \c last if no such iterator exists.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param pred A predicate used to test range elements.
+ *  \return The first iterator \c i such that <tt>pred(*i)</tt> is \c false, or \c last.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  struct greater_than_four
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 4;
+ *    }
+ *  };
+ *
+ *  struct greater_than_ten
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 10;
+ *    }
+ *  };
+ *
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find_if_not(thrust::device, input.begin(), input.end(), greater_than_four()); // returns input.first()
+ *
+ *  iter = thrust::find_if_not(thrust::device, input.begin(), input.end(), greater_than_ten());  // returns input.first()
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ *  \see mismatch
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if_not(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          Predicate pred);
+
+
+/*! \p find_if_not returns the first iterator \c i in the range 
+ *  <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c false
+ *  or \c last if no such iterator exists.
+ *
+ *  \param first Beginning of the sequence to search.
+ *  \param last End of the sequence to search.
+ *  \param pred A predicate used to test range elements.
+ *  \return The first iterator \c i such that <tt>pred(*i)</tt> is \c false, or \c last.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/find.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct greater_than_four
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 4;
+ *    }
+ *  };
+ *
+ *  struct greater_than_ten
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x > 10;
+ *    }
+ *  };
+ *
+ *  ...
+ *  thrust::device_vector<int> input(4);
+ *
+ *  input[0] = 0;
+ *  input[1] = 5;
+ *  input[2] = 3;
+ *  input[3] = 7;
+ *
+ *  thrust::device_vector<int>::iterator iter;
+ *
+ *  iter = thrust::find_if_not(input.begin(), input.end(), greater_than_four()); // returns input.first()
+ *
+ *  iter = thrust::find_if_not(input.begin(), input.end(), greater_than_ten());  // returns input.first()
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ *  \see mismatch
+ */
+template <typename InputIterator, typename Predicate>
+InputIterator find_if_not(InputIterator first,
+                          InputIterator last,
+                          Predicate pred);
+
+/*! \} // end searching
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/find.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d05e3ea16bd5949c0bede7d822e59d0940dcf5d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/for_each.h
@@ -0,0 +1,278 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/for_each.h
+ *  \brief Applies a function to each element in a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup modifying
+ *  \ingroup transformations
+ *  \{
+ */
+
+
+/*! \p for_each applies the function object \p f to each element
+ *  in the range <tt>[first, last)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution. For this reason, this version of \p for_each
+ *  does not return a copy of the function object.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param f The function object to apply to the range <tt>[first, last)</tt>.
+ *  \return last
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each to print the elements
+ *  of a \p thrust::device_vector using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *  ...
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::device, d_vec.begin(), d_vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename UnaryFunction>
+__host__ __device__
+InputIterator for_each(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator first,
+                       InputIterator last,
+                       UnaryFunction f);
+
+
+/*! \p for_each_n applies the function object \p f to each element
+ *  in the range <tt>[first, first + n)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the input sequence.
+ *  \param f The function object to apply to the range <tt>[first, first + n)</tt>.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam Size is an integral type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each_n to print the elements
+ *  of a \p device_vector using the \p thrust::device parallelization policy.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each_n(thrust::device, d_vec.begin(), d_vec.size(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename UnaryFunction>
+__host__ __device__
+InputIterator for_each_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         Size n,
+                         UnaryFunction f);
+
+/*! \p for_each applies the function object \p f to each element
+ *  in the range <tt>[first, last)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution. For this reason, this version of \p for_each
+ *  does not return a copy of the function object.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param f The function object to apply to the range <tt>[first, last)</tt>.
+ *  \return last
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each to print the elements
+ *  of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <stdio.h>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each(d_vec.begin(), d_vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template<typename InputIterator,
+         typename UnaryFunction>
+InputIterator for_each(InputIterator first,
+                       InputIterator last,
+                       UnaryFunction f);
+
+
+/*! \p for_each_n applies the function object \p f to each element
+ *  in the range <tt>[first, first + n)</tt>; \p f's return value, if any,
+ *  is ignored. Unlike the C++ Standard Template Library function
+ *  <tt>std::for_each</tt>, this version offers no guarantee on
+ *  order of execution.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param n The size of the input sequence.
+ *  \param f The function object to apply to the range <tt>[first, first + n)</tt>.
+ *  \return <tt>first + n</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam Size is an integral type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction does not apply any non-constant operation through its argument.
+ *
+ *  The following code snippet demonstrates how to use \p for_each_n to print the elements
+ *  of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <stdio.h>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      // note that using printf in a __device__ function requires
+ *      // code compiled for a GPU with compute capability 2.0 or
+ *      // higher (nvcc --arch=sm_20)
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  thrust::device_vector<int> d_vec(3);
+ *  d_vec[0] = 0; d_vec[1] = 1; d_vec[2] = 2;
+ *
+ *  thrust::for_each_n(d_vec.begin(), d_vec.size(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ *
+ *  \see for_each
+ *  \see https://en.cppreference.com/w/cpp/algorithm/for_each
+ */
+template<typename InputIterator,
+         typename Size,
+         typename UnaryFunction>
+InputIterator for_each_n(InputIterator first,
+                         Size n,
+                         UnaryFunction f);
+
+/*! \} // end modifying
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/for_each.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/functional.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/functional.h
new file mode 100644
index 0000000000000000000000000000000000000000..0608f4b3d454ed4d51d2e42537a0d35b9d9c62c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/functional.h
@@ -0,0 +1,1719 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file functional.h
+ *  \brief Function objects and tools for manipulating them
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <functional>
+#include <thrust/detail/functional/placeholder.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup function_objects Function Objects
+ */
+
+template<typename Operation> struct unary_traits;
+
+template<typename Operation> struct binary_traits;
+
+/*! \addtogroup function_object_adaptors Function Object Adaptors
+ *  \ingroup function_objects
+ *  \{
+ */
+
+/*! \p unary_function is an empty base class: it contains no member functions
+ *  or member variables, but only type information. The only reason it exists
+ *  is to make it more convenient to define types that are models of the
+ *  concept Adaptable Unary Function. Specifically, any model of Adaptable
+ *  Unary Function must define nested \c typedefs. Those \c typedefs are
+ *  provided by the base class \p unary_function.
+ *
+ *  The following code snippet demonstrates how to construct an
+ *  Adaptable Unary Function using \p unary_function.
+ *
+ *  \code
+ *  struct sine : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) { return sinf(x); }
+ *  };
+ *  \endcode
+ *
+ *  \note Because C++11 language support makes the functionality of
+ *        \c unary_function obsolete, its use is optional if C++11 language
+ *        features are enabled.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/unary_function
+ *  \see binary_function
+ */
+template<typename Argument,
+         typename Result>
+struct unary_function
+{
+  /*! \typedef argument_type
+   *  \brief The type of the function object's argument.
+   */
+  typedef Argument argument_type;
+
+  /*! \typedef result_type;
+   *  \brief The type of the function object's result.
+   */
+  typedef Result   result_type;
+}; // end unary_function
+
+/*! \p binary_function is an empty base class: it contains no member functions
+ *  or member variables, but only type information. The only reason it exists
+ *  is to make it more convenient to define types that are models of the
+ *  concept Adaptable Binary Function. Specifically, any model of Adaptable
+ *  Binary Function must define nested \c typedefs. Those \c typedefs are
+ *  provided by the base class \p binary_function.
+ *
+ *  The following code snippet demonstrates how to construct an
+ *  Adaptable Binary Function using \p binary_function.
+ *
+ *  \code
+ *  struct exponentiate : public thrust::binary_function<float,float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x, float y) { return powf(x,y); }
+ *  };
+ *  \endcode
+ *
+ *  \note Because C++11 language support makes the functionality of
+ *        \c binary_function obsolete, its use is optional if C++11 language
+ *        features are enabled.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/binary_function
+ *  \see unary_function
+ */
+template<typename Argument1,
+         typename Argument2,
+         typename Result>
+struct binary_function
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef Argument1 first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef Argument2 second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef Result    result_type;
+}; // end binary_function
+
+/*! \}
+ */
+
+
+/*! \addtogroup predefined_function_objects Predefined Function Objects
+ *  \ingroup function_objects
+ */
+
+/*! \addtogroup arithmetic_operations Arithmetic Operations
+ *  \ingroup predefined_function_objects
+ *  \{
+ */
+
+#define THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(func, impl)                   \
+  template <>                                                                  \
+  struct func<void>                                                            \
+  {                                                                            \
+    using is_transparent = void;                                               \
+    __thrust_exec_check_disable__                                              \
+    template <typename T>                                                      \
+    __host__ __device__                                                        \
+    constexpr auto operator()(T&& x) const                                     \
+      noexcept(noexcept(impl)) THRUST_TRAILING_RETURN(decltype(impl))          \
+    {                                                                          \
+      return impl;                                                             \
+    }                                                                          \
+  }
+
+#define THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(func, impl)                  \
+  template <>                                                                  \
+  struct func<void>                                                            \
+  {                                                                            \
+    using is_transparent = void;                                               \
+    __thrust_exec_check_disable__                                              \
+    template <typename T1, typename T2>                                        \
+    __host__ __device__                                                        \
+    constexpr auto operator()(T1&& t1, T2&& t2) const                          \
+      noexcept(noexcept(impl)) THRUST_TRAILING_RETURN(decltype(impl))          \
+    {                                                                          \
+      return impl;                                                             \
+    }                                                                          \
+  }
+
+#define THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(func, op)                 \
+  THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(                                   \
+    func, THRUST_FWD(t1) op THRUST_FWD(t2))
+
+
+/*! \p plus is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>plus<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x+y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x+y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>plus</tt> to sum two
+ *  device_vectors of \c floats.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *  thrust::device_vector<float> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 75);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::plus<float>());
+ *  // V3 is now {76, 77, 78, ..., 1075}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/plus
+ *  \see binary_function
+ */
+template<typename T = void>
+struct plus
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs + rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs + rhs;
+  }
+}; // end plus
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(plus, +);
+
+/*! \p minus is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>minus<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x-y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x-y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>minus</tt> to subtract
+ *  a device_vector of \c floats from another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *  thrust::device_vector<float> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 75);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::minus<float>());
+ *  // V3 is now {-74, -73, -72, ..., 925}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/minus
+ *  \see binary_function
+ */
+template<typename T = void>
+struct minus
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs - rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs - rhs;
+  }
+}; // end minus
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(minus, -);
+
+/*! \p multiplies is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>multiplies<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x*y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x*y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>multiplies</tt> to multiply
+ *  two device_vectors of \c floats.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *  thrust::device_vector<float> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 75);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::multiplies<float>());
+ *  // V3 is now {75, 150, 225, ..., 75000}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/multiplies
+ *  \see binary_function
+ */
+template<typename T = void>
+struct multiplies
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs * rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs * rhs;
+  }
+}; // end multiplies
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(multiplies, *);
+
+/*! \p divides is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>divides<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x/y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x/y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>divides</tt> to divide
+ *  one device_vectors of \c floats by another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *  thrust::device_vector<float> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 75);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::divides<float>());
+ *  // V3 is now {1/75, 2/75, 3/75, ..., 1000/75}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/divides
+ *  \see binary_function
+ */
+template<typename T = void>
+struct divides
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs / rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs / rhs;
+  }
+}; // end divides
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(divides, /);
+
+/*! \p modulus is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>modulus<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x \% y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x \% y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>modulus</tt> to take
+ *  the modulus of one device_vectors of \c floats by another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *  thrust::device_vector<float> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 75);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::modulus<int>());
+ *  // V3 is now {1%75, 2%75, 3%75, ..., 1000%75}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/modulus
+ *  \see binary_function
+ */
+template<typename T = void>
+struct modulus
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs % rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs % rhs;
+  }
+}; // end modulus
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(modulus, %);
+
+/*! \p negate is a function object. Specifically, it is an Adaptable Unary Function.
+ *  If \c f is an object of class <tt>negate<T></tt>, and \c x is an object
+ *  of class \c T, then <tt>f(x)</tt> returns <tt>-x</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x is an object of type \p T, then <tt>-x</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>negate</tt> to negate
+ *  the elements of a device_vector of \c floats.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(),
+ *                    thrust::negate<float>());
+ *  // V2 is now {-1, -2, -3, ..., -1000}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/negate
+ *  \see unary_function
+ */
+template<typename T = void>
+struct negate
+{
+  /*! \typedef argument_type
+   *  \brief The type of the function object's argument.
+   */
+  typedef T argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>-x</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &x) const
+  {
+    return -x;
+  }
+}; // end negate
+
+THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(negate, -THRUST_FWD(x));
+
+/*! \p square is a function object. Specifically, it is an Adaptable Unary Function.
+ *  If \c f is an object of class <tt>square<T></tt>, and \c x is an object
+ *  of class \c T, then <tt>f(x)</tt> returns <tt>x*x</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x is an object of type \p T, then <tt>x*x</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>square</tt> to square
+ *  the elements of a device_vector of \c floats.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<float> V1(N);
+ *  thrust::device_vector<float> V2(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(),
+ *                    thrust::square<float>());
+ *  // V2 is now {1, 4, 9, ..., 1000000}
+ *  \endcode
+ *
+ *  \see unary_function
+ */
+template<typename T = void>
+struct square
+{
+  /*! \typedef argument_type
+   *  \brief The type of the function object's argument.
+   */
+  typedef T argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>x*x</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &x) const
+  {
+    return x*x;
+  }
+}; // end square
+
+THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(square, x*x);
+
+/*! \}
+ */
+
+/*! \addtogroup comparison_operations Comparison Operations
+ *  \ingroup predefined_function_objects
+ *  \{
+ */
+
+/*! \p equal_to is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>equal_to<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x == y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/equal_to
+ *  \see binary_function
+ */
+template<typename T = void>
+struct equal_to
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs == rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs == rhs;
+  }
+}; // end equal_to
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(equal_to, ==);
+
+/*! \p not_equal_to is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>not_equal_to<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x != y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/not_equal_to
+ *  \see binary_function
+ */
+template<typename T = void>
+struct not_equal_to
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs != rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs != rhs;
+  }
+}; // end not_equal_to
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(not_equal_to, !=);
+
+/*! \p greater is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>greater<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x > y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/greater
+ *  \see binary_function
+ */
+template<typename T = void>
+struct greater
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs > rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs > rhs;
+  }
+}; // end greater
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(greater, >);
+
+/*! \p less is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>less<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x < y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/less
+ *  \see binary_function
+ */
+template<typename T = void>
+struct less
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs < rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs < rhs;
+  }
+}; // end less
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(less, <);
+
+/*! \p greater_equal is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>greater_equal<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x >= y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/greater_equal
+ *  \see binary_function
+ */
+template<typename T = void>
+struct greater_equal
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs >= rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs >= rhs;
+  }
+}; // end greater_equal
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(greater_equal, >=);
+
+/*! \p less_equal is a function object. Specifically, it is an Adaptable Binary
+ *  Predicate, which means it is a function object that tests the truth or falsehood
+ *  of some condition. If \c f is an object of class <tt>less_equal<T></tt> and \c x
+ *  and \c y are objects of class \c T, then <tt>f(x,y)</tt> returns \c true if
+ *  <tt>x <= y</tt> and \c false otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/less_equal
+ *  \see binary_function
+ */
+template<typename T = void>
+struct less_equal
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs <= rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs <= rhs;
+  }
+}; // end less_equal
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(less_equal, <=);
+
+/*! \}
+ */
+
+
+/*! \addtogroup logical_operations Logical Operations
+ *  \ingroup predefined_function_objects
+ *  \{
+ */
+
+/*! \p logical_and is a function object. Specifically, it is an Adaptable Binary Predicate,
+ *  which means it is a function object that tests the truth or falsehood of some condition.
+ *  If \c f is an object of class <tt>logical_and<T></tt> and \c x and \c y are objects of
+ *  class \c T (where \c T is convertible to \c bool) then <tt>f(x,y)</tt> returns \c true
+ *  if and only if both \c x and \c y are \c true.
+ *
+ *  \tparam T must be convertible to \c bool.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/logical_and
+ *  \see binary_function
+ */
+template<typename T = void>
+struct logical_and
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs && rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs && rhs;
+  }
+}; // end logical_and
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(logical_and, &&);
+
+/*! \p logical_or is a function object. Specifically, it is an Adaptable Binary Predicate,
+ *  which means it is a function object that tests the truth or falsehood of some condition.
+ *  If \c f is an object of class <tt>logical_or<T></tt> and \c x and \c y are objects of
+ *  class \c T (where \c T is convertible to \c bool) then <tt>f(x,y)</tt> returns \c true
+ *  if and only if either \c x or \c y are \c true.
+ *
+ *  \tparam T must be convertible to \c bool.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/logical_or
+ *  \see binary_function
+ */
+template<typename T = void>
+struct logical_or
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>lhs || rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs || rhs;
+  }
+}; // end logical_or
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(logical_or, ||);
+
+/*! \p logical_not is a function object. Specifically, it is an Adaptable Predicate,
+ *  which means it is a function object that tests the truth or falsehood of some condition.
+ *  If \c f is an object of class <tt>logical_not<T></tt> and \c x is an object of
+ *  class \c T (where \c T is convertible to \c bool) then <tt>f(x)</tt> returns \c true
+ *  if and only if \c x is \c false.
+ *
+ *  \tparam T must be convertible to \c bool.
+ *
+ *  The following code snippet demonstrates how to use \p logical_not to transform
+ *  a device_vector of \c bools into its logical complement.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  thrust::device_vector<bool> V;
+ *  ...
+ *  thrust::transform(V.begin(), V.end(), V.begin(), thrust::logical_not<bool>());
+ *  // The elements of V are now the logical complement of what they were prior
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/logical_not
+ *  \see unary_function
+ */
+template<typename T = void>
+struct logical_not
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef bool result_type;
+
+  /*! Function call operator. The return value is <tt>!x</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool operator()(const T &x) const
+  {
+    return !x;
+  }
+}; // end logical_not
+
+THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(logical_not, !THRUST_FWD(x));
+
+/*! \}
+ */
+
+/*! \addtogroup bitwise_operations Bitwise Operations
+ *  \ingroup predefined_function_objects
+ *  \{
+ */
+
+/*! \p bit_and is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>bit_and<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x&y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x&y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>bit_and</tt> to take
+ *  the bitwise AND of one device_vector of \c ints by another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<int> V1(N);
+ *  thrust::device_vector<int> V2(N);
+ *  thrust::device_vector<int> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 13);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::bit_and<int>());
+ *  // V3 is now {1&13, 2&13, 3&13, ..., 1000%13}
+ *  \endcode
+ *
+ *  \see binary_function
+ */
+template<typename T = void>
+struct bit_and
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs & rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs & rhs;
+  }
+}; // end bit_and
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_and, &);
+
+/*! \p bit_or is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>bit_and<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x|y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x|y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>bit_or</tt> to take
+ *  the bitwise OR of one device_vector of \c ints by another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<int> V1(N);
+ *  thrust::device_vector<int> V2(N);
+ *  thrust::device_vector<int> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 13);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::bit_or<int>());
+ *  // V3 is now {1|13, 2|13, 3|13, ..., 1000|13}
+ *  \endcode
+ *
+ *  \see binary_function
+ */
+template<typename T = void>
+struct bit_or
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs | rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs | rhs;
+  }
+}; // end bit_or
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_or, |);
+
+/*! \p bit_xor is a function object. Specifically, it is an Adaptable Binary Function.
+ *  If \c f is an object of class <tt>bit_and<T></tt>, and \c x and \c y are objects
+ *  of class \c T, then <tt>f(x,y)</tt> returns <tt>x^y</tt>.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x and \c y are objects of type \p T, then <tt>x^y</tt> must be defined and must have a return type that is convertible to \c T.
+ *
+ *  The following code snippet demonstrates how to use <tt>bit_xor</tt> to take
+ *  the bitwise XOR of one device_vector of \c ints by another.
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/fill.h>
+ *  #include <thrust/transform.h>
+ *  ...
+ *  const int N = 1000;
+ *  thrust::device_vector<int> V1(N);
+ *  thrust::device_vector<int> V2(N);
+ *  thrust::device_vector<int> V3(N);
+ *
+ *  thrust::sequence(V1.begin(), V1.end(), 1);
+ *  thrust::fill(V2.begin(), V2.end(), 13);
+ *
+ *  thrust::transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),
+ *                    thrust::bit_xor<int>());
+ *  // V3 is now {1^13, 2^13, 3^13, ..., 1000^13}
+ *  \endcode
+ *
+ *  \see binary_function
+ */
+template<typename T = void>
+struct bit_xor
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs ^ rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs ^ rhs;
+  }
+}; // end bit_xor
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP(bit_xor, ^);
+
+/*! \}
+ */
+
+/*! \addtogroup generalized_identity_operations Generalized Identity Operations
+ *  \ingroup predefined_function_objects
+ *  \{
+ */
+
+/*! \p identity is a Unary Function that represents the identity function: it takes
+ *  a single argument \c x, and returns \c x.
+ *
+ *  \tparam T No requirements on \p T.
+ *
+ *  The following code snippet demonstrates that \p identity returns its
+ *  argument.
+ *
+ *  \code
+ *  #include <thrust/functional.h>
+ *  #include <assert.h>
+ *  ...
+ *  int x = 137;
+ *  thrust::identity<int> id;
+ *  assert(x == id(x));
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/identity
+ *  \see unary_function
+ */
+template<typename T = void>
+struct identity
+{
+  /*! \typedef argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>x</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T &operator()(const T &x) const
+  {
+    return x;
+  }
+}; // end identity
+
+THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION(identity, THRUST_FWD(x));
+
+/*! \p maximum is a function object that takes two arguments and returns the greater
+ *  of the two. Specifically, it is an Adaptable Binary Function. If \c f is an
+ *  object of class <tt>maximum<T></tt> and \c x and \c y are objects of class \c T
+ *  <tt>f(x,y)</tt> returns \c x if <tt>x > y</tt> and \c y, otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates that \p maximum returns its
+ *  greater argument.
+ *
+ *  \code
+ *  #include <thrust/functional.h>
+ *  #include <assert.h>
+ *  ...
+ *  int x =  137;
+ *  int y = -137;
+ *  thrust::maximum<int> mx;
+ *  assert(x == mx(x,y));
+ *  \endcode
+ *
+ *  \see minimum
+ *  \see min
+ *  \see binary_function
+ */
+template<typename T = void>
+struct maximum
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>rhs < lhs ? lhs : rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs < rhs ? rhs : lhs;
+  }
+}; // end maximum
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(maximum,
+                                          t1 < t2 ? THRUST_FWD(t2)
+                                                  : THRUST_FWD(t1));
+
+/*! \p minimum is a function object that takes two arguments and returns the lesser
+ *  of the two. Specifically, it is an Adaptable Binary Function. If \c f is an
+ *  object of class <tt>minimum<T></tt> and \c x and \c y are objects of class \c T
+ *  <tt>f(x,y)</tt> returns \c x if <tt>x < y</tt> and \c y, otherwise.
+ *
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates that \p minimum returns its
+ *  lesser argument.
+ *
+ *  \code
+ *  #include <thrust/functional.h>
+ *  #include <assert.h>
+ *  ...
+ *  int x =  137;
+ *  int y = -137;
+ *  thrust::minimum<int> mn;
+ *  assert(y == mn(x,y));
+ *  \endcode
+ *
+ *  \see maximum
+ *  \see max
+ *  \see binary_function
+ */
+template<typename T = void>
+struct minimum
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T result_type;
+
+  /*! Function call operator. The return value is <tt>lhs < rhs ? lhs : rhs</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr T operator()(const T &lhs, const T &rhs) const
+  {
+    return lhs < rhs ? lhs : rhs;
+  }
+}; // end minimum
+
+THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION(minimum,
+                                          t1 < t2 ? THRUST_FWD(t1)
+                                                  : THRUST_FWD(t2));
+
+/*! \p project1st is a function object that takes two arguments and returns
+ *  its first argument; the second argument is unused. It is essentially a
+ *  generalization of identity to the case of a Binary Function.
+ *
+ *  \code
+ *  #include <thrust/functional.h>
+ *  #include <assert.h>
+ *  ...
+ *  int x =  137;
+ *  int y = -137;
+ *  thrust::project1st<int> pj1;
+ *  assert(x == pj1(x,y));
+ *  \endcode
+ *
+ *  \see identity
+ *  \see project2nd
+ *  \see binary_function
+ */
+template<typename T1 = void, typename T2 = void>
+struct project1st
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T1 first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T2 second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T1 result_type;
+
+  /*! Function call operator. The return value is <tt>lhs</tt>.
+   */
+  __host__ __device__
+  constexpr const T1 &operator()(const T1 &lhs, const T2 & /*rhs*/) const
+  {
+    return lhs;
+  }
+}; // end project1st
+
+template <>
+struct project1st<void, void>
+{
+  using is_transparent = void;
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&&) const
+    noexcept(noexcept(THRUST_FWD(t1)))
+    THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)))
+  {
+    return THRUST_FWD(t1);
+  }
+};
+
+/*! \p project2nd is a function object that takes two arguments and returns
+ *  its second argument; the first argument is unused. It is essentially a
+ *  generalization of identity to the case of a Binary Function.
+ *
+ *  \code
+ *  #include <thrust/functional.h>
+ *  #include <assert.h>
+ *  ...
+ *  int x =  137;
+ *  int y = -137;
+ *  thrust::project2nd<int> pj2;
+ *  assert(y == pj2(x,y));
+ *  \endcode
+ *
+ *  \see identity
+ *  \see project1st
+ *  \see binary_function
+ */
+template<typename T1 = void, typename T2 = void>
+struct project2nd
+{
+  /*! \typedef first_argument_type
+   *  \brief The type of the function object's first argument.
+   */
+  typedef T1 first_argument_type;
+
+  /*! \typedef second_argument_type
+   *  \brief The type of the function object's second argument.
+   */
+  typedef T2 second_argument_type;
+
+  /*! \typedef result_type
+   *  \brief The type of the function object's result;
+   */
+  typedef T2 result_type;
+
+  /*! Function call operator. The return value is <tt>rhs</tt>.
+   */
+  __host__ __device__
+  constexpr const T2 &operator()(const T1 &/*lhs*/, const T2 &rhs) const
+  {
+    return rhs;
+  }
+}; // end project2nd
+
+template <>
+struct project2nd<void, void>
+{
+  using is_transparent = void;
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&&, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t2);
+  }
+};
+
+/*! \}
+ */
+
+// odds and ends
+
+/*! \addtogroup function_object_adaptors
+ *  \{
+ */
+
+/*! \p unary_negate is a function object adaptor: it is an Adaptable Predicate
+ *  that represents the logical negation of some other Adaptable Predicate.
+ *  That is: if \c f is an object of class <tt>unary_negate<AdaptablePredicate></tt>,
+ *  then there exists an object \c pred of class \c AdaptablePredicate such
+ *  that <tt>f(x)</tt> always returns the same value as <tt>!pred(x)</tt>.
+ *  There is rarely any reason to construct a <tt>unary_negate</tt> directly;
+ *  it is almost always easier to use the helper function not1.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/unary_negate
+ *  \see not1
+ */
+template<typename Predicate>
+struct unary_negate
+    : public thrust::unary_function<typename Predicate::argument_type, bool>
+{
+  /*! Constructor takes a \p Predicate object to negate.
+   *  \param p The \p Predicate object to negate.
+   */
+  __host__ __device__
+  explicit unary_negate(Predicate p) : pred(p){}
+
+  /*! Function call operator. The return value is <tt>!pred(x)</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  bool operator()(const typename Predicate::argument_type& x) { return !pred(x); }
+
+  /*! \cond
+   */
+  Predicate pred;
+  /*! \endcond
+   */
+}; // end unary_negate
+
+/*! \p not1 is a helper function to simplify the creation of Adaptable Predicates:
+ *  it takes an Adaptable Predicate \p pred as an argument and returns a new Adaptable
+ *  Predicate that represents the negation of \p pred. That is: if \c pred is an object
+ *  of a type which models Adaptable Predicate, then the the type of the result
+ *  \c npred of <tt>not1(pred)</tt> is also a model of Adaptable Predicate and
+ *  <tt>npred(x)</tt> always returns the same value as <tt>!pred(x)</tt>.
+ *
+ *  \param pred The Adaptable Predicate to negate.
+ *  \return A new object, <tt>npred</tt> such that <tt>npred(x)</tt> always returns
+ *          the same value as <tt>!pred(x)</tt>.
+ *
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_negate">Adaptable Predicate</a>.
+ *
+ *  \see unary_negate
+ *  \see not2
+ */
+template<typename Predicate>
+  __host__ __device__
+  unary_negate<Predicate> not1(const Predicate &pred);
+
+/*! \p binary_negate is a function object adaptor: it is an Adaptable Binary
+ *  Predicate that represents the logical negation of some other Adaptable
+ *  Binary Predicate. That is: if \c f is an object of class <tt>binary_negate<AdaptablePredicate></tt>,
+ *  then there exists an object \c pred of class \c AdaptableBinaryPredicate
+ *  such that <tt>f(x,y)</tt> always returns the same value as <tt>!pred(x,y)</tt>.
+ *  There is rarely any reason to construct a <tt>binary_negate</tt> directly;
+ *  it is almost always easier to use the helper function not2.
+ *
+ *  \see https://en.cppreference.com/w/cpp/utility/functional/binary_negate
+ */
+template<typename Predicate>
+struct binary_negate
+    : public thrust::binary_function<typename Predicate::first_argument_type,
+                                     typename Predicate::second_argument_type,
+                                     bool>
+{
+  /*! Constructor takes a \p Predicate object to negate.
+   *  \param p The \p Predicate object to negate.
+   */
+  __host__ __device__
+  explicit binary_negate(Predicate p) : pred(p){}
+
+  /*! Function call operator. The return value is <tt>!pred(x,y)</tt>.
+   */
+  __thrust_exec_check_disable__
+  __host__ __device__
+  bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y)
+  {
+      return !pred(x,y);
+  }
+
+  /*! \cond
+   */
+  Predicate pred;
+  /*! \endcond
+   */
+}; // end binary_negate
+
+/*! \p not2 is a helper function to simplify the creation of Adaptable Binary Predicates:
+ *  it takes an Adaptable Binary Predicate \p pred as an argument and returns a new Adaptable
+ *  Binary Predicate that represents the negation of \p pred. That is: if \c pred is an object
+ *  of a type which models Adaptable Binary Predicate, then the the type of the result
+ *  \c npred of <tt>not2(pred)</tt> is also a model of Adaptable Binary Predicate and
+ *  <tt>npred(x,y)</tt> always returns the same value as <tt>!pred(x,y)</tt>.
+ *
+ *  \param pred The Adaptable Binary Predicate to negate.
+ *  \return A new object, <tt>npred</tt> such that <tt>npred(x,y)</tt> always returns
+ *          the same value as <tt>!pred(x,y)</tt>.
+ *
+ *  \tparam Binary Predicate is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/AdaptableBinaryPredicate">Adaptable Binary Predicate</a>.
+ *
+ *  \see binary_negate
+ *  \see not1
+ */
+template<typename BinaryPredicate>
+  __host__ __device__
+  binary_negate<BinaryPredicate> not2(const BinaryPredicate &pred);
+
+/*! \}
+ */
+
+
+/*! \addtogroup placeholder_objects Placeholder Objects
+ *  \ingroup function_objects
+ *  \{
+ */
+
+
+/*! \namespace thrust::placeholders
+ *  \brief Facilities for constructing simple functions inline.
+ *
+ *  Objects in the \p thrust::placeholders namespace may be used to create simple arithmetic functions inline
+ *  in an algorithm invocation. Combining placeholders such as \p _1 and \p _2 with arithmetic operations such as \c +
+ *  creates an unnamed function object which applies the operation to their arguments.
+ *
+ *  The type of placeholder objects is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use the placeholders \p _1 and \p _2 with \p thrust::transform
+ *  to implement the SAXPY computation:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> x(4), y(4);
+ *    x[0] = 1;
+ *    x[1] = 2;
+ *    x[2] = 3;
+ *    x[3] = 4;
+ *
+ *    y[0] = 1;
+ *    y[1] = 1;
+ *    y[2] = 1;
+ *    y[3] = 1;
+ *
+ *    float a = 2.0f;
+ *
+ *    using namespace thrust::placeholders;
+ *
+ *    thrust::transform(x.begin(), x.end(), y.begin(), y.begin(),
+ *      a * _1 + _2
+ *    );
+ *
+ *    // y is now {3, 5, 7, 9}
+ *  }
+ *  \endcode
+ */
+namespace placeholders
+{
+
+
+/*! \p thrust::placeholders::_1 is the placeholder for the first function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<0>::type _1;
+
+
+/*! \p thrust::placeholders::_2 is the placeholder for the second function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<1>::type _2;
+
+
+/*! \p thrust::placeholders::_3 is the placeholder for the third function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<2>::type _3;
+
+
+/*! \p thrust::placeholders::_4 is the placeholder for the fourth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<3>::type _4;
+
+
+/*! \p thrust::placeholders::_5 is the placeholder for the fifth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<4>::type _5;
+
+
+/*! \p thrust::placeholders::_6 is the placeholder for the sixth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<5>::type _6;
+
+
+/*! \p thrust::placeholders::_7 is the placeholder for the seventh function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<6>::type _7;
+
+
+/*! \p thrust::placeholders::_8 is the placeholder for the eighth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<7>::type _8;
+
+
+/*! \p thrust::placeholders::_9 is the placeholder for the ninth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<8>::type _9;
+
+
+/*! \p thrust::placeholders::_10 is the placeholder for the tenth function parameter.
+ */
+THRUST_INLINE_CONSTANT thrust::detail::functional::placeholder<9>::type _10;
+
+
+} // end placeholders
+
+
+/*! \} // placeholder_objects
+ */
+
+#undef THRUST_UNARY_FUNCTOR_VOID_SPECIALIZATION
+#undef THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION
+#undef THRUST_BINARY_FUNCTOR_VOID_SPECIALIZATION_OP
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/functional.inl>
+#include <thrust/detail/functional/operators.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/future.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/future.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8fb7544b1777c2b52178ebdd8b829b29b5fc8b1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/future.h
@@ -0,0 +1,176 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/future.h
+ *  \brief `thrust::future`, an asynchronous value type.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/execution_policy.h>
+#include <thrust/detail/static_assert.h>
+
+#include <utility>
+
+/*
+// #include the host system's pointer.h header.
+#define __THRUST_HOST_SYSTEM_POINTER_HEADER <__THRUST_HOST_SYSTEM_ROOT/pointer.h>
+  #include __THRUST_HOST_SYSTEM_POINTER_HEADER
+#undef __THRUST_HOST_SYSTEM_POINTER_HEADER
+*/
+
+// #include the device system's pointer.h header.
+#define __THRUST_DEVICE_SYSTEM_POINTER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/pointer.h>
+  #include __THRUST_DEVICE_SYSTEM_POINTER_HEADER
+#undef __THRUST_DEVICE_SYSTEM_POINTER_HEADER
+
+/*
+// #include the host system's future.h header.
+#define __THRUST_HOST_SYSTEM_FUTURE_HEADER <__THRUST_HOST_SYSTEM_ROOT/future.h>
+  #include __THRUST_HOST_SYSTEM_FUTURE_HEADER
+#undef __THRUST_HOST_SYSTEM_FUTURE_HEADER
+*/
+
+// #include the device system's future.h header.
+#define __THRUST_DEVICE_SYSTEM_FUTURE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/future.h>
+  #include __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FUTURE_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+// `select_unique_(future|event)_type` is a hook for choosing the
+// `unique_eager_event`/`unique_eager_future` type for a system. `decltype` is
+// used to determine the return type of an ADL call to
+// `select_unique_eager_(future|event)_type(system)`; that return type should
+// be the correct event/future type for `system`. Overloads should only be
+// declared, not defined.
+
+namespace unimplemented
+{
+
+struct no_unique_eager_event_type_found {};
+
+inline __host__ 
+no_unique_eager_event_type_found
+unique_eager_event_type(...) noexcept;
+
+struct no_unique_eager_future_type_found {};
+
+template <typename T>
+__host__ 
+no_unique_eager_future_type_found
+unique_eager_future_type(...) noexcept;
+
+} // namespace unimplemented
+
+namespace unique_eager_event_type_detail
+{
+
+using unimplemented::unique_eager_event_type;
+
+template <typename System>
+using select = decltype(
+  unique_eager_event_type(std::declval<System>())
+);
+
+} // namespace unique_eager_event_type_detail
+
+namespace unique_eager_future_type_detail
+{
+
+using unimplemented::unique_eager_future_type;
+
+template <typename System, typename T>
+using select = decltype(
+  unique_eager_future_type<T>(std::declval<System>())
+);
+
+} // namespace unique_eager_future_type_detail
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename System>
+using unique_eager_event = unique_eager_event_type_detail::select<System>;
+
+template <typename System>
+using event = unique_eager_event<System>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename System, typename T>
+using unique_eager_future = unique_eager_future_type_detail::select<System, T>;
+
+template <typename System, typename T>
+using future = unique_eager_future<System, T>;
+
+/*
+///////////////////////////////////////////////////////////////////////////////
+
+using host_unique_eager_event = unique_eager_event_type_detail::select<
+  thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag
+>;
+using host_event = host_unique_eager_event;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+using host_unique_eager_future = unique_eager_future_type_detail::select<
+  thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag, T
+>;
+template <typename T>
+using host_future = host_unique_eager_future<T>;
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+
+using device_unique_eager_event = unique_eager_event_type_detail::select<
+  thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag
+>;
+
+using device_event = device_unique_eager_event;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+using device_unique_eager_future = unique_eager_future_type_detail::select<
+  thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag, T
+>;
+
+template <typename T>
+using device_future = device_unique_eager_future<T>;
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct new_stream_t final {};
+
+THRUST_INLINE_CONSTANT new_stream_t new_stream{};
+
+///////////////////////////////////////////////////////////////////////////////
+
+using thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::when_all;
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/gather.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..41acc22a34e8cc3c9c1afb699e9e20f18e822914
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/gather.h
@@ -0,0 +1,445 @@
+/*
+ *  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 gather.h
+ *  \brief Irregular copying from a source range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup gathering
+ *  \ingroup copying
+ *  \{
+ */
+
+
+/*! \p gather copies elements from a source array into a destination range according 
+ *  to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>, the
+ *  value <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather is the inverse of thrust::scatter.
+ *
+ *  The following code snippet demonstrates how to use \p gather to reorder
+ *  a range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  // mark even indices with a 1; odd indices with a 0
+ *  int values[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // gather all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10);
+ *  thrust::gather(thrust::device,
+ *                 d_map.begin(), d_map.end(),
+ *                 d_values.begin(),
+ *                 d_output.begin());
+ *  // d_output is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  \endcode
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator                                               map_first,
+                        InputIterator                                               map_last,
+                        RandomAccessIterator                                        input_first,
+                        OutputIterator                                              result);
+
+
+/*! \p gather copies elements from a source array into a destination range according 
+ *  to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>, the
+ *  value <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather is the inverse of thrust::scatter.
+ *
+ *  The following code snippet demonstrates how to use \p gather to reorder
+ *  a range.
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  // mark even indices with a 1; odd indices with a 0
+ *  int values[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // gather all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10);
+ *  thrust::gather(d_map.begin(), d_map.end(),
+ *                 d_values.begin(),
+ *                 d_output.begin());
+ *  // d_output is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  \endcode
+ */
+template<typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather(InputIterator        map_first,
+                        InputIterator        map_last,
+                        RandomAccessIterator input_first,
+                        OutputIterator       result);
+
+
+/*! \p gather_if conditionally copies elements from a source array into a destination 
+ *  range according to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>,
+ *  such that the value of <tt>\*(stencil + (i - map_first))</tt> is \c true, the value
+ *  <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param stencil Beginning of the range of predicate values.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c bool.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (map_last - map_first))</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather_if is the inverse of \p scatter_if.
+ *
+ *  The following code snippet demonstrates how to use \p gather_if to gather selected values from
+ *  an input range using the \p thrust::device execution policy:
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  int values[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // select elements at even-indexed locations
+ *  int stencil[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_stencil(stencil, stencil + 10);
+ *
+ *  // map all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10, 7);
+ *  thrust::gather_if(thrust::device,
+ *                    d_map.begin(), d_map.end(),
+ *                    d_stencil.begin(),
+ *                    d_values.begin(),
+ *                    d_output.begin());
+ *  // d_output is now {0, 7, 4, 7, 8, 7, 3, 7, 7, 7}
+ *  \endcode
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result);
+
+
+/*! \p gather_if conditionally copies elements from a source array into a destination 
+ *  range according to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>,
+ *  such that the value of <tt>\*(stencil + (i - map_first))</tt> is \c true, the value
+ *  <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param stencil Beginning of the range of predicate values.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c bool.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (map_last - map_first))</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather_if is the inverse of \p scatter_if.
+ *
+ *  The following code snippet demonstrates how to use \p gather_if to gather selected values from
+ *  an input range.
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *
+ *  int values[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // select elements at even-indexed locations
+ *  int stencil[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_stencil(stencil, stencil + 10);
+ *
+ *  // map all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10, 7);
+ *  thrust::gather_if(d_map.begin(), d_map.end(),
+ *                    d_stencil.begin(),
+ *                    d_values.begin(),
+ *                    d_output.begin());
+ *  // d_output is now {0, 7, 4, 7, 8, 7, 3, 7, 7, 7}
+ *  \endcode
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result);
+
+
+/*! \p gather_if conditionally copies elements from a source array into a destination 
+ *  range according to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>
+ *  such that the value of <tt>pred(\*(stencil + (i - map_first)))</tt> is \c true,
+ *  the value <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param stencil Beginning of the range of predicate values.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *  \param pred Predicate to apply to the stencil values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (map_last - map_first))</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather_if is the inverse of \p scatter_if.
+ *
+ *  The following code snippet demonstrates how to use \p gather_if to gather selected values from
+ *  an input range based on an arbitrary selection function using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *
+ *  int values[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // we will select an element when our stencil is even
+ *  int stencil[10] = {0, 3, 4, 1, 4, 1, 2, 7, 8, 9};
+ *  thrust::device_vector<int> d_stencil(stencil, stencil + 10);
+ *
+ *  // map all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10, 7);
+ *  thrust::gather_if(thrust::device,
+ *                    d_map.begin(), d_map.end(),
+ *                    d_stencil.begin(),
+ *                    d_values.begin(),
+ *                    d_output.begin(),
+ *                    is_even());
+ *  // d_output is now {0, 7, 4, 7, 8, 7, 3, 7, 7, 7}
+ *  \endcode
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result,
+                           Predicate                                                   pred);
+
+
+/*! \p gather_if conditionally copies elements from a source array into a destination 
+ *  range according to a map. For each input iterator \c i in the range <tt>[map_first, map_last)</tt>
+ *  such that the value of <tt>pred(\*(stencil + (i - map_first)))</tt> is \c true,
+ *  the value <tt>input_first[\*i]</tt> is assigned to <tt>*(result + (i - map_first))</tt>.
+ *  \p RandomAccessIterator must permit random access.
+ *
+ *  \param map_first Beginning of the range of gather locations.
+ *  \param map_last End of the range of gather locations.
+ *  \param stencil Beginning of the range of predicate values.
+ *  \param input_first Beginning of the source range.
+ *  \param result Beginning of the destination range.
+ *  \param pred Predicate to apply to the stencil values.
+ *
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a> and \c RandomAccessIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[map_first, map_last)</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (map_last - map_first))</tt> shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *  \pre The input data shall not overlap the range <tt>[result, result + (map_last - map_first))</tt>.
+ *
+ *  \remark \p gather_if is the inverse of \p scatter_if.
+ *
+ *  The following code snippet demonstrates how to use \p gather_if to gather selected values from
+ *  an input range based on an arbitrary selection function.
+ *
+ *  \code
+ *  #include <thrust/gather.h>
+ *  #include <thrust/device_vector.h>
+ *  
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *
+ *  int values[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // we will select an element when our stencil is even
+ *  int stencil[10] = {0, 3, 4, 1, 4, 1, 2, 7, 8, 9};
+ *  thrust::device_vector<int> d_stencil(stencil, stencil + 10);
+ *
+ *  // map all even indices into the first half of the range
+ *  // and odd indices to the last half of the range
+ *  int map[10]   = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10, 7);
+ *  thrust::gather_if(d_map.begin(), d_map.end(),
+ *                    d_stencil.begin(),
+ *                    d_values.begin(),
+ *                    d_output.begin(),
+ *                    is_even());
+ *  // d_output is now {0, 7, 4, 7, 8, 7, 3, 7, 7, 7}
+ *  \endcode
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result,
+                           Predicate            pred);
+
+/*! \} // gathering
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/gather.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/generate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/generate.h
new file mode 100644
index 0000000000000000000000000000000000000000..d47295344607d3112089cd1ed775d16fa4b81adf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/generate.h
@@ -0,0 +1,211 @@
+/*
+ *  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 generate.h
+ *  \brief Fills a range with values "generated" from a function of no arguments
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \{
+ */
+
+
+/*! \p generate assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,last)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element in the range of interest.
+ *  \param last The last element in the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Generator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>,
+ *          and \p Generator's \c result_type is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate(thrust::host, v.begin(), v.end(), rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Generator>
+__host__ __device__
+  void generate(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                Generator gen);
+
+
+/*! \p generate assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,last)</tt>.
+ *
+ *  \param first The first element in the range of interest.
+ *  \param last The last element in the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,last)</tt>.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Generator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>,
+ *          and \p Generator's \c result_type is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand.
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate(v.begin(), v.end(), rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate_n
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template<typename ForwardIterator,
+         typename Generator>
+  void generate(ForwardIterator first,
+                ForwardIterator last,
+                Generator gen);
+
+
+/*! \p generate_n assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,first + n)</tt>. The return value is <tt>first + n</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element in the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,first + n)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Size is an integral type (either signed or unsigned).
+ *  \tparam Generator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>,
+ *          and \p Generator's \c result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  #include <cstdlib>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate_n(thrust::host, v.begin(), 10, rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template<typename DerivedPolicy,
+         typename OutputIterator,
+         typename Size,
+         typename Generator>
+__host__ __device__
+  OutputIterator generate_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            OutputIterator first,
+                            Size n,
+                            Generator gen);
+
+
+/*! \p generate_n assigns the result of invoking \p gen, a function object that takes no arguments,
+ *  to each element in the range <tt>[first,first + n)</tt>. The return value is <tt>first + n</tt>.
+ *
+ *  \param first The first element in the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param gen A function argument, taking no parameters, used to generate values to assign to
+ *             elements in the range <tt>[first,first + n)</tt>.
+ *
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Size is an integral type (either signed or unsigned).
+ *  \tparam Generator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional">Generator</a>,
+ *          and \p Generator's \c result_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *
+ *  The following code snippet demonstrates how to fill a \c host_vector with random numbers,
+ *  using the standard C library function \c rand.
+ *
+ *  \code
+ *  #include <thrust/generate.h>
+ *  #include <thrust/host_vector.h>
+ *  #include <stdlib.h>
+ *  ...
+ *  thrust::host_vector<int> v(10);
+ *  srand(13);
+ *  thrust::generate_n(v.begin(), 10, rand);
+ *
+ *  // the elements of v are now pseudo-random numbers
+ *  \endcode
+ *
+ *  \see generate
+ *  \see https://en.cppreference.com/w/cpp/algorithm/generate
+ */
+template<typename OutputIterator,
+         typename Size,
+         typename Generator>
+  OutputIterator generate_n(OutputIterator first,
+                            Size n,
+                            Generator gen);
+
+
+/*! \} // end transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/generate.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/host_vector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/host_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb925ea9ce855cb9257ff8277d81a185022d87dd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/host_vector.h
@@ -0,0 +1,534 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file host_vector.h
+ *  \brief A dynamically-sizable array of elements which resides in memory
+ *         accessible to hosts.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/detail/vector_base.h>
+
+#include <initializer_list>
+#include <vector>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup container_classes Container Classes
+ *  \addtogroup host_containers Host Containers
+ *  \ingroup container_classes
+ *  \{
+ */
+
+/*! A \p host_vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p host_vector may vary dynamically; memory management is
+ *  automatic. The memory associated with a \p host_vector resides in memory
+ *  accessible to hosts.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see device_vector
+ *  \see universal_vector
+ */
+template<typename T, typename Alloc = std::allocator<T> >
+  class host_vector
+    : public detail::vector_base<T,Alloc>
+{
+  private:
+    typedef detail::vector_base<T,Alloc> Parent;
+
+  public:
+    /*! \cond
+     */
+    typedef typename Parent::size_type  size_type;
+    typedef typename Parent::value_type value_type;
+    /*! \endcond
+     */
+
+    /*! This constructor creates an empty \p host_vector.
+     */
+    __host__
+    host_vector(void)
+      :Parent() {}
+
+    /*! This constructor creates an empty \p host_vector.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    __host__
+    host_vector(const Alloc &alloc)
+      :Parent(alloc) {}
+
+    /*! The destructor erases the elements.
+     */
+    //  Define an empty destructor to explicitly specify
+    //  its execution space qualifier, as a workaround for nvcc warning
+    __host__
+    ~host_vector(void) {}
+
+    /*! This constructor creates a \p host_vector with the given
+     *  size.
+     *  \param n The number of elements to initially create.
+     */
+    __host__
+    explicit host_vector(size_type n)
+      :Parent(n) {}
+
+    /*! This constructor creates a \p host_vector with the given
+     *  size.
+     *  \param n The number of elements to initially create.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    __host__
+    explicit host_vector(size_type n, const Alloc &alloc)
+      :Parent(n,alloc) {}
+
+    /*! This constructor creates a \p host_vector with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     */
+    __host__
+    explicit host_vector(size_type n, const value_type &value)
+      :Parent(n,value) {}
+
+    /*! This constructor creates a \p host_vector with copies
+     *  of an exemplar element.
+     *  \param n The number of elements to initially create.
+     *  \param value An element to copy.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    __host__
+    explicit host_vector(size_type n, const value_type &value, const Alloc &alloc)
+      :Parent(n,value,alloc) {}
+
+    /*! Copy constructor copies from an exemplar \p host_vector.
+     *  \param v The \p host_vector to copy.
+     */
+    __host__
+    host_vector(const host_vector &v)
+      :Parent(v) {}
+
+    /*! Copy constructor copies from an exemplar \p host_vector.
+     *  \param v The \p host_vector to copy.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    __host__
+    host_vector(const host_vector &v, const Alloc &alloc)
+      :Parent(v,alloc) {}
+
+  #if THRUST_CPP_DIALECT >= 2011
+    /*! Move constructor moves from another host_vector.
+     *  \param v The host_vector to move.
+     */
+     __host__
+    host_vector(host_vector &&v)
+      :Parent(std::move(v)) {}
+
+    /*! Move constructor moves from another host_vector.
+     *  \param v The host_vector to move.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+     __host__
+    host_vector(host_vector &&v, const Alloc &alloc)
+      :Parent(std::move(v),alloc) {}
+  #endif
+
+  /*! Assign operator copies from an exemplar \p host_vector.
+   *  \param v The \p host_vector to copy.
+   */
+  __host__
+  host_vector &operator=(const host_vector &v)
+  { Parent::operator=(v); return *this; }
+
+  #if THRUST_CPP_DIALECT >= 2011
+    /*! Move assign operator moves from another host_vector.
+     *  \param v The host_vector to move.
+     */
+     __host__
+     host_vector &operator=(host_vector &&v)
+     { Parent::operator=(std::move(v)); return *this; }
+  #endif
+
+    /*! Copy constructor copies from an exemplar \p host_vector with different type.
+     *  \param v The \p host_vector to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector(const host_vector<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign operator copies from an exemplar \p host_vector with different type.
+     *  \param v The \p host_vector to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector &operator=(const host_vector<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this; }
+
+    /*! Copy constructor copies from an exemplar <tt>std::vector</tt>.
+     *  \param v The <tt>std::vector</tt> to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector(const std::vector<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign operator copies from an exemplar <tt>std::vector</tt>.
+     *  \param v The <tt>std::vector</tt> to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector &operator=(const std::vector<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this;}
+
+    /*! Copy construct from a \p vector_base whose element type is convertible
+     *  to \c T.
+     *
+     *  \param v The \p vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector(const detail::vector_base<OtherT,OtherAlloc> &v)
+      :Parent(v) {}
+
+    /*! Assign a \p vector_base whose element type is convertible to \c T.
+     *
+     *  \param v The \p vector_base to copy.
+     */
+    template<typename OtherT, typename OtherAlloc>
+    __host__
+    host_vector &operator=(const detail::vector_base<OtherT,OtherAlloc> &v)
+    { Parent::operator=(v); return *this; }
+    
+    /*! This constructor builds a \p host_vector from an intializer_list.
+     *  \param il The intializer_list.
+     */
+    host_vector(std::initializer_list<T> il)
+      :Parent(il) {}
+      
+    /*! This constructor builds a \p host_vector from an intializer_list.
+     *  \param il The intializer_list.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    host_vector(std::initializer_list<T> il, const Alloc &alloc)
+      :Parent(il, alloc) {}
+      
+    /*! Assign an \p intializer_list with a matching element type
+     *  \param il The intializer_list.
+     */
+    host_vector &operator=(std::initializer_list<T> il)
+    { Parent::operator=(il); return *this; }
+
+    /*! This constructor builds a \p host_vector from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     */
+    template<typename InputIterator>
+    __host__
+    host_vector(InputIterator first, InputIterator last)
+      :Parent(first, last) {}
+
+    /*! This constructor builds a \p host_vector from a range.
+     *  \param first The beginning of the range.
+     *  \param last The end of the range.
+     *  \param alloc The allocator to use by this host_vector.
+     */
+    template<typename InputIterator>
+    __host__
+    host_vector(InputIterator first, InputIterator last, const Alloc &alloc)
+      :Parent(first, last, alloc) {}
+
+// declare these members for the purpose of Doxygenating them
+// they actually exist in a derived-from class
+#if 0
+    /*! \brief Resizes this vector to the specified number of elements.
+     *  \param new_size Number of elements this vector should contain.
+     *  \param x Data with which new elements should be populated.
+     *  \throw std::length_error If n exceeds max_size().
+     *
+     *  This method will resize this vector to the specified number of
+     *  elements.  If the number is smaller than this vector's current
+     *  size this vector is truncated, otherwise this vector is
+     *  extended and new elements are populated with given data.
+     */
+    void resize(size_type new_size, const value_type &x = value_type());
+
+    /*! Returns the number of elements in this vector.
+     */
+    size_type size(void) const;
+
+    /*! Returns the size() of the largest possible vector.
+     *  \return The largest possible return value of size().
+     */
+    size_type max_size(void) const;
+
+    /*! \brief If n is less than or equal to capacity(), this call has no effect.
+     *         Otherwise, this method is a request for allocation of additional memory. If
+     *         the request is successful, then capacity() is greater than or equal to
+     *         n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
+     *  \throw std::length_error If n exceeds max_size().
+     */
+    void reserve(size_type n);
+
+    /*! Returns the number of elements which have been reserved in this
+     *  vector.
+     */
+    size_type capacity(void) const;
+
+    /*! This method shrinks the capacity of this vector to exactly
+     *  fit its elements.
+     */
+    void shrink_to_fit(void);
+
+    /*! \brief Subscript access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read/write reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    reference operator[](size_type n);
+
+    /*! \brief Subscript read access to the data contained in this vector_dev.
+     *  \param n The index of the element for which data should be accessed.
+     *  \return Read reference to data.
+     *
+     *  This operator allows for easy, array-style, data access.
+     *  Note that data access with this operator is unchecked and
+     *  out_of_range lookups are not defined.
+     */
+    const_reference operator[](size_type n) const;
+
+    /*! This method returns an iterator pointing to the beginning of
+     *  this vector.
+     *  \return mStart
+     */
+    iterator begin(void);
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator begin(void) const;
+
+    /*! This method returns a const_iterator pointing to the beginning
+     *  of this vector.
+     *  \return mStart
+     */
+    const_iterator cbegin(void) const;
+
+    /*! This method returns a reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    reverse_iterator rbegin(void);
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator rbegin(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to the beginning of
+     *  this vector's reversed sequence.
+     *  \return A const_reverse_iterator pointing to the beginning of this
+     *          vector's reversed sequence.
+     */
+    const_reverse_iterator crbegin(void) const;
+
+    /*! This method returns an iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    iterator end(void);
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator end(void) const;
+
+    /*! This method returns a const_iterator pointing to one element past the
+     *  last of this vector.
+     *  \return begin() + size().
+     */
+    const_iterator cend(void) const;
+
+    /*! This method returns a reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    reverse_iterator rend(void);
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator rend(void) const;
+
+    /*! This method returns a const_reverse_iterator pointing to one element past the
+     *  last of this vector's reversed sequence.
+     *  \return rbegin() + size().
+     */
+    const_reverse_iterator crend(void) const;
+
+    /*! This method returns a const_reference referring to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    const_reference front(void) const;
+
+    /*! This method returns a reference pointing to the first element of this
+     *  vector.
+     *  \return The first element of this vector.
+     */
+    reference front(void);
+
+    /*! This method returns a const reference pointing to the last element of
+     *  this vector.
+     *  \return The last element of this vector.
+     */
+    const_reference back(void) const;
+
+    /*! This method returns a reference referring to the last element of
+     *  this vector_dev.
+     *  \return The last element of this vector.
+     */
+    reference back(void);
+
+    /*! This method returns a pointer to this vector's first element.
+     *  \return A pointer to the first element of this vector.
+     */
+    pointer data(void);
+
+    /*! This method returns a const_pointer to this vector's first element.
+     *  \return a const_pointer to the first element of this vector.
+     */
+    const_pointer data(void) const;
+
+    /*! This method resizes this vector to 0.
+     */
+    void clear(void);
+
+    /*! This method returns true iff size() == 0.
+     *  \return true if size() == 0; false, otherwise.
+     */
+    bool empty(void) const;
+
+    /*! This method appends the given element to the end of this vector.
+     *  \param x The element to append.
+     */
+    void push_back(const value_type &x);
+
+    /*! This method erases the last element of this vector, invalidating
+     *  all iterators and references to it.
+     */
+    void pop_back(void);
+
+    /*! This method swaps the contents of this host_vector with another vector.
+     *  \param v The vector with which to swap.
+     */
+    void swap(host_vector &v);
+
+    /*! This method removes the element at position pos.
+     *  \param pos The position of the element of interest.
+     *  \return An iterator pointing to the new location of the element that followed the element
+     *          at position pos.
+     */
+    iterator erase(iterator pos);
+
+    /*! This method removes the range of elements [first,last) from this vector.
+     *  \param first The beginning of the range of elements to remove.
+     *  \param last The end of the range of elements to remove.
+     *  \return An iterator pointing to the new location of the element that followed the last
+     *          element in the sequence [first,last).
+     */
+    iterator erase(iterator first, iterator last);
+
+    /*! This method inserts a single copy of a given exemplar value at the
+     *  specified position in this vector.
+     *  \param position The insertion position.
+     *  \param x The exemplar element to copy & insert.
+     *  \return An iterator pointing to the newly inserted element.
+     */
+    iterator insert(iterator position, const T &x);
+
+    /*! This method inserts a copy of an exemplar value to a range at the
+     *  specified position in this vector.
+     *  \param position The insertion position
+     *  \param n The number of insertions to perform.
+     *  \param x The value to replicate and insert.
+     */
+    void insert(iterator position, size_type n, const T &x);
+
+    /*! This method inserts a copy of an input range at the specified position
+     *  in this vector.
+     *  \param position The insertion position.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator>Input Iterator</a>,
+     *                        and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>.
+     */
+    template<typename InputIterator>
+    void insert(iterator position, InputIterator first, InputIterator last);
+
+    /*! This version of \p assign replicates a given exemplar
+     *  \p n times into this vector.
+     *  \param n The number of times to copy \p x.
+     *  \param x The exemplar element to replicate.
+     */
+    void assign(size_type n, const T &x);
+
+    /*! This version of \p assign makes this vector a copy of a given input range.
+     *  \param first The beginning of the range to copy.
+     *  \param last  The end of the range to copy.
+     *
+     *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">Input Iterator</a>.
+     */
+    template<typename InputIterator>
+    void assign(InputIterator first, InputIterator last);
+
+    /*! This method returns a copy of this vector's allocator.
+     *  \return A copy of the alloctor used by this vector.
+     */
+    allocator_type get_allocator(void) const;
+#endif // end doxygen-only members
+};
+
+/*! Exchanges the values of two vectors.
+ *  \p x The first \p host_vector of interest.
+ *  \p y The second \p host_vector of interest.
+ */
+template<typename T, typename Alloc>
+  void swap(host_vector<T,Alloc> &a, host_vector<T,Alloc> &b)
+{
+  a.swap(b);
+}
+
+/*! \}
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/inner_product.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/inner_product.h
new file mode 100644
index 0000000000000000000000000000000000000000..80068cf0c834a147f8a754f92bc1322ecbb57b9b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/inner_product.h
@@ -0,0 +1,262 @@
+/*
+ *  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 inner_product.h
+ *  \brief Mathematical inner product between ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup transformed_reductions Transformed Reductions
+ *  \ingroup reductions
+ *  \{
+ */
+
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + ... </tt>
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt>
+ *          and <tt>[first2, last2)</tt> plus \p init.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x is an object of type \p OutputType, and \c y is an object of \p InputIterator1's \c value_type,
+ *          and \c z is an object of \p InputIterator2's \c value_type, then <tt>x + y * z</tt> is defined
+ *          and is convertible to \p OutputType.
+ *
+ *  The following code demonstrates how to use \p inner_product to
+ *  compute the dot product of two vectors using the \p thrust::host execution policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, 0.0f);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputType>
+__host__ __device__
+OutputType inner_product(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first1,
+                         InputIterator1 last1,
+                         InputIterator2 first2,
+                         OutputType init);
+
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>init + (*first1 * *first2) + (*(first1+1) * *(first2+1)) + ... </tt>
+ *
+ *  Unlike the C++ Standard Template Library function <tt>std::inner_product</tt>,
+ *  this version offers no guarantee on order of execution.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt>
+ *          and <tt>[first2, last2)</tt> plus \p init.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and if \c x is an object of type \p OutputType, and \c y is an object of \p InputIterator1's \c value_type,
+ *          and \c z is an object of \p InputIterator2's \c value_type, then <tt>x + y * z</tt> is defined
+ *          and is convertible to \p OutputType.
+ *
+ *  The following code demonstrates how to use \p inner_product to
+ *  compute the dot product of two vectors.
+ *
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float result = thrust::inner_product(vec1, vec1 + 3, vec2, 0.0f);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template<typename InputIterator1, typename InputIterator2, typename OutputType>
+OutputType inner_product(InputIterator1 first1, InputIterator1 last1,
+                         InputIterator2 first2, OutputType init);
+
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  This version of \p inner_product is identical to the first, except that is uses
+ *  two user-supplied function objects instead of \c operator+ and \c operator*.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>binary_op1( init, binary_op2(*first1, *first2) ), ... </tt>
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \param binary_op1 Generalized addition operation.
+ *  \param binary_op2 Generalized multiplication operation.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is convertible to \p BinaryFunction2's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *          and \p InputIterator2's \c value_type is convertible to \p BinaryFunction2's \c second_argument_type.
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p OutputType is convertible to \p BinaryFunction1's \c first_argument_type.
+ *  \tparam BinaryFunction1 is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction1's \c return_type is convertible to \p OutputType.
+ *  \tparam BinaryFunction2 is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction2's \c return_type is convertible to \p BinaryFunction1's \c second_argument_type.
+ * 
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float init = 0.0f;
+ *  thrust::plus<float>       binary_op1;
+ *  thrust::multiplies<float> binary_op2;
+ *
+ *  float result = thrust::inner_product(thrust::host, vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputType,
+         typename BinaryFunction1,
+         typename BinaryFunction2>
+__host__ __device__
+OutputType inner_product(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first1,
+                         InputIterator1 last1,
+                         InputIterator2 first2,
+                         OutputType init, 
+                         BinaryFunction1 binary_op1,
+                         BinaryFunction2 binary_op2);
+
+
+/*! \p inner_product calculates an inner product of the ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, first2 + (last1 - first1))</tt>.
+ *
+ *  This version of \p inner_product is identical to the first, except that is uses
+ *  two user-supplied function objects instead of \c operator+ and \c operator*.
+ *
+ *  Specifically, this version of \p inner_product computes the sum
+ *  <tt>binary_op1( init, binary_op2(*first1, *first2) ), ... </tt>
+ *
+ *  Unlike the C++ Standard Template Library function <tt>std::inner_product</tt>,
+ *  this version offers no guarantee on order of execution.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1 The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param init Initial value of the result.
+ *  \param binary_op1 Generalized addition operation.
+ *  \param binary_op2 Generalized multiplication operation.
+ *  \return The inner product of sequences <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator1's \c value_type is convertible to \p BinaryFunction2's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *          and \p InputIterator2's \c value_type is convertible to \p BinaryFunction2's \c second_argument_type.
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p OutputType is convertible to \p BinaryFunction1's \c first_argument_type.
+ *  \tparam BinaryFunction1 is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction1's \c return_type is convertible to \p OutputType.
+ *  \tparam BinaryFunction2 is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction2's \c return_type is convertible to \p BinaryFunction1's \c second_argument_type.
+ * 
+ *  \code
+ *  #include <thrust/inner_product.h>
+ *  ...
+ *  float vec1[3] = {1.0f, 2.0f, 5.0f};
+ *  float vec2[3] = {4.0f, 1.0f, 5.0f};
+ *
+ *  float init = 0.0f;
+ *  thrust::plus<float>       binary_op1;
+ *  thrust::multiplies<float> binary_op2;
+ *
+ *  float result = thrust::inner_product(vec1, vec1 + 3, vec2, init, binary_op1, binary_op2);
+ *
+ *  // result == 31.0f
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/inner_product
+ */
+template<typename InputIterator1, typename InputIterator2, typename OutputType,
+         typename BinaryFunction1, typename BinaryFunction2>
+OutputType inner_product(InputIterator1 first1, InputIterator1 last1,
+                         InputIterator2 first2, OutputType init, 
+                         BinaryFunction1 binary_op1, BinaryFunction2 binary_op2);
+
+
+/*! \} // end transformed_reductions
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/inner_product.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/constant_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/constant_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6eec28e70e404fcd22c3689cbaa51f71893ec44
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/constant_iterator.h
@@ -0,0 +1,250 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/constant_iterator.h
+ *  \brief An iterator which returns a constant value when
+ *         dereferenced
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/constant_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p constant_iterator is an iterator which represents a pointer into a range
+ *  of constant values. This iterator is useful for creating a range filled with the same
+ *  value without explicitly storing it in memory. Using \p constant_iterator saves both
+ *  memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p constant_iterator whose
+ *  \c value_type is \c int and whose value is \c 10.
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *
+ *  thrust::constant_iterator<int> iter(10);
+ *
+ *  *iter;    // returns 10
+ *  iter[0];  // returns 10
+ *  iter[1];  // returns 10
+ *  iter[13]; // returns 10
+ *
+ *  // and so on...
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p constant_iterator with the
+ *  \p thrust::transform function to increment all elements of a sequence by the
+ *  same value. We will create a temporary \p constant_iterator with the function
+ *  \p make_constant_iterator function in order to avoid explicitly specifying
+ *  its type:
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> data(4);
+ *    data[0] = 3;
+ *    data[1] = 7;
+ *    data[2] = 2;
+ *    data[3] = 5;
+ *    
+ *    // add 10 to all values in data
+ *    thrust::transform(data.begin(), data.end(),
+ *                      thrust::make_constant_iterator(10),
+ *                      data.begin(),
+ *                      thrust::plus<int>());
+ *    
+ *    // data is now [13, 17, 12, 15]
+ *    
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_constant_iterator
+ */
+template<typename Value,
+         typename Incrementable = use_default,
+         typename System = use_default>
+  class constant_iterator
+    : public detail::constant_iterator_base<Value, Incrementable, System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::type          super_t;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::incrementable incrementable;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Null constructor initializes this \p constant_iterator's constant using its
+     *  null constructor.
+     */
+    __host__ __device__
+    constant_iterator()
+      : super_t(), m_value() {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator into this
+     *  \p constant_iterator.
+     *
+     *  \p rhs The constant_iterator to copy.
+     */
+    __host__ __device__
+    constant_iterator(constant_iterator const &rhs)
+      : super_t(rhs.base()), m_value(rhs.m_value) {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator with related
+     *  System type.
+     *
+     *  \param rhs The \p constant_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    constant_iterator(constant_iterator<Value,Incrementable,OtherSystem> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<constant_iterator<Value,Incrementable,OtherSystem> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()), m_value(rhs.value()) {}
+
+    /*! This constructor receives a value to use as the constant value of this
+     *  \p constant_iterator and an index specifying the location of this
+     *  \p constant_iterator in a sequence.
+     *  
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    constant_iterator(value_type const& v, incrementable const &i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This constructor is templated to allow construction from a value type and
+     *  incrementable type related this this \p constant_iterator's respective types.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    template<typename OtherValue, typename OtherIncrementable>
+    __host__ __device__
+    constant_iterator(OtherValue const& v, OtherIncrementable const& i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This method returns the value of this \p constant_iterator's constant value.
+     *  \return A \c const reference to this \p constant_iterator's constant value.
+     */
+    __host__ __device__
+    Value const& value() const
+    { return m_value; }
+
+    /*! \cond
+     */
+
+  protected:
+    __host__ __device__
+    Value const& value_reference() const
+    { return m_value; }
+
+    __host__ __device__
+    Value & value_reference()
+    { return m_value; }
+  
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_value;
+    }
+
+  private:
+    Value m_value;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  from values given for both value and index. The type of \p constant_iterator
+ *  may be inferred by the compiler from the types of its parameters.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \param i The index of the returned \p constant_iterator within a sequence.
+ *           The type of this parameter defaults to \c int. In the default case,
+ *           the value of this parameter is \c 0.
+ *
+ *  \return A new \p constant_iterator with constant value & index as given
+ *          by \p x & \p i.
+ *
+ *  \see constant_iterator
+ */
+template<typename ValueT, typename IndexT>
+inline __host__ __device__
+constant_iterator<ValueT, IndexT> make_constant_iterator(ValueT x, IndexT i = int())
+{
+  return constant_iterator<ValueT, IndexT>(x, i);
+} // end make_constant_iterator()
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  using only a parameter for the desired constant value. The value of the
+ *  returned \p constant_iterator's index is set to \c 0.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \return A new \p constant_iterator with constant value equal to \p x and
+ *          index equal to \c 0.
+ *  \see constant_iterator
+ */
+template<typename V>
+inline __host__ __device__
+constant_iterator<V> make_constant_iterator(V x)
+{
+  return constant_iterator<V>(x, 0);
+} // end make_constant_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/counting_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/counting_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..f66cb97ef82aa568c870baf2089111f1263d9587
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/counting_iterator.h
@@ -0,0 +1,246 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/counting_iterator.h
+ *  \brief An iterator which returns an increasing incrementable value
+ *         when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams 2003.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+
+// #include the details first
+#include <thrust/iterator/detail/counting_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p counting_iterator is an iterator which represents a pointer into a range
+ *  of sequentially changing values. This iterator is useful for creating a range
+ *  filled with a sequence without explicitly storing it in memory. Using
+ *  \p counting_iterator saves memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p counting_iterator whose
+ *  \c value_type is \c int and which sequentially increments by \c 1.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  ...
+ *  // create iterators
+ *  thrust::counting_iterator<int> first(10);
+ *  thrust::counting_iterator<int> last = first + 3;
+ *
+ *  first[0]   // returns 10
+ *  first[1]   // returns 11
+ *  first[100] // returns 110
+ *
+ *  // sum of [first, last)
+ *  thrust::reduce(first, last);   // returns 33 (i.e. 10 + 11 + 12)
+ *
+ *  // initialize vector to [0,1,2,..]
+ *  thrust::counting_iterator<int> iter(0);
+ *  thrust::device_vector<int> vec(500);
+ *  thrust::copy(iter, iter + vec.size(), vec.begin());
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p counting_iterator with the
+ *  \p thrust::copy_if function to compute the indices of the non-zero elements
+ *  of a \p device_vector. In this example, we use the \p make_counting_iterator
+ *  function to avoid specifying the type of the \p counting_iterator.
+ *
+ *  \code
+ *  #include <thrust/iterator/counting_iterator.h>
+ *  #include <thrust/copy.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *   // this example computes indices for all the nonzero values in a sequence
+ *
+ *   // sequence of zero and nonzero values
+ *   thrust::device_vector<int> stencil(8);
+ *   stencil[0] = 0;
+ *   stencil[1] = 1;
+ *   stencil[2] = 1;
+ *   stencil[3] = 0;
+ *   stencil[4] = 0;
+ *   stencil[5] = 1;
+ *   stencil[6] = 0;
+ *   stencil[7] = 1;
+ *
+ *   // storage for the nonzero indices
+ *   thrust::device_vector<int> indices(8);
+ *
+ *   // compute indices of nonzero elements
+ *   typedef thrust::device_vector<int>::iterator IndexIterator;
+ *
+ *   // use make_counting_iterator to define the sequence [0, 8)
+ *   IndexIterator indices_end = thrust::copy_if(thrust::make_counting_iterator(0),
+ *                                               thrust::make_counting_iterator(8),
+ *                                               stencil.begin(),
+ *                                               indices.begin(),
+ *                                               thrust::identity<int>());
+ *   // indices now contains [1,2,5,7]
+ *
+ *   return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_counting_iterator
+ */
+template<typename Incrementable,
+         typename System = use_default,
+         typename Traversal = use_default,
+         typename Difference = use_default>
+  class counting_iterator
+    : public detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type
+{
+    /*! \cond
+     */
+    typedef typename detail::counting_iterator_base<Incrementable, System, Traversal, Difference>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+  public:
+    typedef typename super_t::reference       reference;
+    typedef typename super_t::difference_type difference_type;
+
+    /*! \endcond
+     */
+
+    /*! Default constructor initializes this \p counting_iterator's counter to
+     * `Incrementable{}`.
+     */
+    __host__ __device__
+    counting_iterator() : super_t(Incrementable{}) {}
+
+    /*! Copy constructor copies the value of another \p counting_iterator into a
+     *  new \p counting_iterator.
+     *
+     *  \p rhs The \p counting_iterator to copy.
+     */
+    __host__ __device__
+    counting_iterator(counting_iterator const &rhs):super_t(rhs.base()){}
+
+    /*! Copy constructor copies the value of another counting_iterator
+     *  with related System type.
+     *
+     *  \param rhs The \p counting_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    counting_iterator(counting_iterator<Incrementable, OtherSystem, Traversal, Difference> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<counting_iterator<Incrementable,OtherSystem,Traversal,Difference> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()){}
+
+    /*! This \c explicit constructor copies the value of an \c Incrementable
+     *  into a new \p counting_iterator's \c Incrementable counter.
+     *
+     *  \param x The initial value of the new \p counting_iterator's \c Incrementable
+     *         counter.
+     */
+    __host__ __device__
+    explicit counting_iterator(Incrementable x):super_t(x){}
+
+#if THRUST_CPP_DIALECT >= 2011
+    counting_iterator & operator=(const counting_iterator &) = default;
+#endif
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    reference dereference() const
+    {
+      return this->base_reference();
+    }
+
+    // note that we implement equal specially for floating point counting_iterator
+    template <typename OtherIncrementable, typename OtherSystem, typename OtherTraversal, typename OtherDifference>
+    __host__ __device__
+    bool equal(counting_iterator<OtherIncrementable, OtherSystem, OtherTraversal, OtherDifference> const& y) const
+    {
+      typedef thrust::detail::counting_iterator_equal<difference_type,Incrementable,OtherIncrementable> e;
+      return e::equal(this->base(), y.base());
+    }
+
+    template <class OtherIncrementable>
+    __host__ __device__
+    difference_type
+    distance_to(counting_iterator<OtherIncrementable, System, Traversal, Difference> const& y) const
+    {
+      typedef typename
+      thrust::detail::eval_if<
+        thrust::detail::is_numeric<Incrementable>::value,
+        thrust::detail::identity_<thrust::detail::number_distance<difference_type, Incrementable, OtherIncrementable> >,
+        thrust::detail::identity_<thrust::detail::iterator_distance<difference_type, Incrementable, OtherIncrementable> >
+      >::type d;
+
+      return d::distance(this->base(), y.base());
+    }
+
+    /*! \endcond
+     */
+}; // end counting_iterator
+
+
+/*! \p make_counting_iterator creates a \p counting_iterator
+ *  using an initial value for its \c Incrementable counter.
+ *
+ *  \param x The initial value of the new \p counting_iterator's counter.
+ *  \return A new \p counting_iterator whose counter has been initialized to \p x.
+ */
+template <typename Incrementable>
+inline __host__ __device__
+counting_iterator<Incrementable> make_counting_iterator(Incrementable x)
+{
+  return counting_iterator<Incrementable>(x);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_assign.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_assign.h
new file mode 100644
index 0000000000000000000000000000000000000000..87192215c3a2c1dcfcbdfda1b7789159d4030e22
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_assign.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// a type which may be assigned any other type
+struct any_assign
+{
+  inline __host__ __device__ any_assign()
+  {}
+
+  template<typename T>
+  inline __host__ __device__ any_assign(T)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  any_assign &operator=(T)
+  {
+    if(0)
+    {
+      // trick the compiler into silencing "warning: this expression has no effect"
+      int *x = 0;
+      *x = 13;
+    } // end if
+
+    return *this;
+  }
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_system_tag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_system_tag.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c5ce6448be39e08a3ecec398b4e9e375a063d3b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/any_system_tag.h
@@ -0,0 +1,33 @@
+/*
+ *  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>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+struct any_system_tag
+  : thrust::execution_policy<any_system_tag>
+{
+  // allow any_system_tag to convert to any type at all
+  // XXX make this safer using enable_if<is_tag<T>> upon c++11
+  template<typename T> operator T () const {return T();}
+};
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/constant_iterator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/constant_iterator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..56bb7a5d01f55fcc59f8df3121cfc2f4e5cf20c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/constant_iterator_base.h
@@ -0,0 +1,71 @@
+/*
+ *  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>
+
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/iterator_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of constant_iterator
+template<typename,typename,typename> class constant_iterator;
+
+namespace detail
+{
+
+template<typename Value,
+         typename Incrementable,
+         typename System>
+  struct constant_iterator_base
+{
+  typedef Value              value_type;
+
+  // the reference type is the same as the value_type.
+  // we wish to avoid returning a reference to the internal state
+  // of the constant_iterator, which is prone to subtle bugs.
+  // consider the temporary iterator created in the expression
+  // *(iter + i)
+  typedef value_type         reference;
+
+  // the incrementable type is int unless otherwise specified
+  typedef typename thrust::detail::ia_dflt_help<
+    Incrementable,
+    thrust::detail::identity_<thrust::detail::intmax_t>
+  >::type incrementable;
+
+  typedef typename thrust::counting_iterator<
+    incrementable,
+    System,
+    thrust::random_access_traversal_tag
+  > base_iterator;
+
+  typedef typename thrust::iterator_adaptor<
+    constant_iterator<Value, Incrementable, System>,
+    base_iterator,
+    value_type, // XXX we may need to pass const value_type here as boost counting_iterator does
+    typename thrust::iterator_system<base_iterator>::type,
+    typename thrust::iterator_traversal<base_iterator>::type,
+    reference
+  > type;
+}; // end constant_iterator_base
+
+} // end detail
+  
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/counting_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/counting_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ee4a9df155651d8294d006255c503d7c65585c05
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/counting_iterator.inl
@@ -0,0 +1,142 @@
+/*
+ *  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>
+
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/numeric_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <cstddef>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of counting_iterator
+template <typename Incrementable, typename System, typename Traversal, typename Difference>
+  class counting_iterator;
+
+namespace detail
+{
+
+template <typename Incrementable, typename System, typename Traversal, typename Difference>
+  struct counting_iterator_base
+{
+  typedef typename thrust::detail::eval_if<
+    // use any_system_tag if we are given use_default
+    thrust::detail::is_same<System,use_default>::value,
+    thrust::detail::identity_<thrust::any_system_tag>,
+    thrust::detail::identity_<System>
+  >::type system;
+
+  typedef typename thrust::detail::ia_dflt_help<
+      Traversal,
+      thrust::detail::eval_if<
+          thrust::detail::is_numeric<Incrementable>::value,
+          thrust::detail::identity_<random_access_traversal_tag>,
+          thrust::iterator_traversal<Incrementable>
+      >
+  >::type traversal;
+
+  // unlike Boost, we explicitly use std::ptrdiff_t as the difference type
+  // for floating point counting_iterators
+  typedef typename thrust::detail::ia_dflt_help<
+    Difference,
+    thrust::detail::eval_if<
+      thrust::detail::is_numeric<Incrementable>::value,
+        thrust::detail::eval_if<
+          thrust::detail::is_integral<Incrementable>::value,
+          thrust::detail::numeric_difference<Incrementable>,
+          thrust::detail::identity_<std::ptrdiff_t>
+        >,
+      thrust::iterator_difference<Incrementable>
+    >
+  >::type difference;
+
+  // our implementation departs from Boost's in that counting_iterator::dereference
+  // returns a copy of its counter, rather than a reference to it. returning a reference
+  // to the internal state of an iterator causes subtle bugs (consider the temporary
+  // iterator created in the expression *(iter + i)) and has no compelling use case
+  typedef thrust::iterator_adaptor<
+    counting_iterator<Incrementable, System, Traversal, Difference>, // self
+    Incrementable,                                                  // Base
+    Incrementable,                                                  // XXX we may need to pass const here as Boost does
+    system,
+    traversal,
+    Incrementable,
+    difference
+  > type;
+}; // end counting_iterator_base
+
+
+template<typename Difference, typename Incrementable1, typename Incrementable2>
+  struct iterator_distance
+{
+  __host__ __device__
+  static Difference distance(Incrementable1 x, Incrementable2 y)
+  {
+    return y - x;
+  }
+};
+
+
+template<typename Difference, typename Incrementable1, typename Incrementable2>
+  struct number_distance
+{
+  __host__ __device__
+  static Difference distance(Incrementable1 x, Incrementable2 y)
+  {
+      return static_cast<Difference>(numeric_distance(x,y));
+  }
+};
+
+
+template<typename Difference, typename Incrementable1, typename Incrementable2, typename Enable = void>
+  struct counting_iterator_equal
+{
+  __host__ __device__
+  static bool equal(Incrementable1 x, Incrementable2 y)
+  {
+    return x == y;
+  }
+};
+
+
+// specialization for floating point equality
+template<typename Difference, typename Incrementable1, typename Incrementable2>
+  struct counting_iterator_equal<
+    Difference,
+    Incrementable1,
+    Incrementable2,
+    typename thrust::detail::enable_if<
+      thrust::detail::is_floating_point<Incrementable1>::value ||
+      thrust::detail::is_floating_point<Incrementable2>::value
+    >::type
+  >
+{
+  __host__ __device__
+  static bool equal(Incrementable1 x, Incrementable2 y)
+  {
+    typedef number_distance<Difference,Incrementable1,Incrementable2> d;
+    return d::distance(x,y) == 0;
+  }
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/device_system_tag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/device_system_tag.h
new file mode 100644
index 0000000000000000000000000000000000000000..b86109d216b75e66ed80a265f200bea693a8773d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/device_system_tag.h
@@ -0,0 +1,30 @@
+/*
+ *  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>
+
+// #include the device system's execution_policy header
+#define __THRUST_DEVICE_SYSTEM_TAG_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/execution_policy.h>
+#include __THRUST_DEVICE_SYSTEM_TAG_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TAG_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag device_system_tag;
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/discard_iterator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/discard_iterator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..38f77b3781204b50e0b92faf244318ebc509a834
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/discard_iterator_base.h
@@ -0,0 +1,64 @@
+/*
+ *  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>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/detail/any_assign.h>
+#include <cstddef> // for std::ptrdiff_t
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of discard_iterator
+template<typename> class discard_iterator;
+
+namespace detail
+{
+
+
+template<typename System>
+  struct discard_iterator_base
+{
+  // XXX value_type should actually be void
+  //     but this interferes with zip_iterator<discard_iterator>
+  typedef any_assign         value_type;
+  typedef any_assign&        reference;
+  typedef std::ptrdiff_t     incrementable;
+
+  typedef typename thrust::counting_iterator<
+    incrementable,
+    System,
+    thrust::random_access_traversal_tag
+  > base_iterator;
+
+  typedef typename thrust::iterator_adaptor<
+    discard_iterator<System>,
+    base_iterator,
+    value_type,
+    typename thrust::iterator_system<base_iterator>::type,
+    typename thrust::iterator_traversal<base_iterator>::type,
+    reference
+  > type;
+}; // end discard_iterator_base
+
+
+} // end detail
+  
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/distance_from_result.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/distance_from_result.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe140344d49c28c6219f18351395f2413e3ef6b9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/distance_from_result.h
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// since both arguments are known to be specializations of iterator_facade,
+// it's legal to access IteratorFacade2::difference_type
+template<typename IteratorFacade1, typename IteratorFacade2>
+  struct distance_from_result
+    : eval_if<
+        is_convertible<IteratorFacade2,IteratorFacade1>::value,
+        identity_<typename IteratorFacade1::difference_type>,
+        identity_<typename IteratorFacade2::difference_type>
+      >
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/host_system_tag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/host_system_tag.h
new file mode 100644
index 0000000000000000000000000000000000000000..58478f8d9266adc233c40952cb305dad003e3275
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/host_system_tag.h
@@ -0,0 +1,30 @@
+/*
+ *  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>
+
+// #include the host system's execution_policy header
+#define __THRUST_HOST_SYSTEM_TAG_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/execution_policy.h>
+#include __THRUST_HOST_SYSTEM_TAG_HEADER
+#undef __THRUST_HOST_SYSTEM_TAG_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::tag host_system_tag;
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/is_iterator_category.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/is_iterator_category.h
new file mode 100644
index 0000000000000000000000000000000000000000..e520452a3ca8d54dbdea5af720fe1cd363ba2a43
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/is_iterator_category.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>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename T>
+  struct is_host_iterator_category
+    : thrust::detail::or_<
+        thrust::detail::is_convertible<T, thrust::input_host_iterator_tag>,
+        thrust::detail::is_convertible<T, thrust::output_host_iterator_tag>
+      >
+{
+}; // end is_host_iterator_category
+
+template <typename T>
+  struct is_device_iterator_category
+    : thrust::detail::or_<
+        thrust::detail::is_convertible<T, thrust::input_device_iterator_tag>,
+        thrust::detail::is_convertible<T, thrust::output_device_iterator_tag>
+      >
+{
+}; // end is_device_iterator_category
+
+
+template <typename T>
+  struct is_iterator_category
+    : thrust::detail::or_<
+        is_host_iterator_category<T>,
+        is_device_iterator_category<T>
+      >
+{
+}; // end is_iterator_category
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_adaptor_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_adaptor_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..1173e414ca55340b7001c12441ce59a8e5bd1ac0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_adaptor_base.h
@@ -0,0 +1,112 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+// forward declaration of iterator_adaptor for iterator_adaptor_base below
+template<typename Derived,
+         typename Base,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference
+>
+class iterator_adaptor;
+
+
+namespace detail
+{
+
+// If T is use_default, return the result of invoking
+// DefaultNullaryFn, otherwise return T.
+// XXX rename to dflt_help
+template <class T, class DefaultNullaryFn>
+struct ia_dflt_help
+  : thrust::detail::eval_if<
+        thrust::detail::is_same<T, thrust::use_default>::value
+      , DefaultNullaryFn
+      , thrust::detail::identity_<T>
+    >
+{
+}; // end ia_dflt_help
+
+
+// A metafunction which computes an iterator_adaptor's base class,
+// a specialization of iterator_facade.
+template<typename Derived,
+         typename Base,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference
+>
+  struct iterator_adaptor_base
+{
+  typedef typename ia_dflt_help<
+    Value,
+    iterator_value<Base>
+  >::type value;
+
+  typedef typename ia_dflt_help<
+    System,
+    thrust::iterator_system<Base>
+  >::type system;
+
+  typedef typename ia_dflt_help<
+    Traversal,
+    thrust::iterator_traversal<Base>
+  >::type traversal;
+
+  typedef typename ia_dflt_help<
+    Reference,
+    thrust::detail::eval_if<
+      thrust::detail::is_same<Value,use_default>::value,
+      thrust::iterator_reference<Base>,
+      thrust::detail::add_reference<Value>
+    >
+  >::type reference;
+
+  typedef typename ia_dflt_help<
+    Difference,
+    iterator_difference<Base>
+  >::type difference;
+
+  typedef thrust::iterator_facade<
+    Derived,
+    value,
+    system,
+    traversal,
+    reference,
+    difference
+  > type;
+}; // end iterator_adaptor_base
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6103b539ae54a869314339c6ebd7ade9e66c266
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_system.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>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/host_system_tag.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// forward declaration
+template <typename> struct is_iterator_system;
+
+template <typename> struct device_iterator_category_to_backend_system;
+
+// XXX this should work entirely differently
+// we should just specialize this metafunction for iterator_category_with_system_and_traversal
+template<typename Category>
+  struct iterator_category_to_system
+    // convertible to host iterator?
+    : eval_if<
+        or_<
+          is_convertible<Category, thrust::input_host_iterator_tag>,
+          is_convertible<Category, thrust::output_host_iterator_tag>
+        >::value,
+
+        detail::identity_<thrust::host_system_tag>,
+        
+        // convertible to device iterator?
+        eval_if<
+          or_<
+            is_convertible<Category, thrust::input_device_iterator_tag>,
+            is_convertible<Category, thrust::output_device_iterator_tag>
+          >::value,
+
+          detail::identity_<thrust::device_system_tag>,
+
+          // unknown system
+          detail::identity_<void>
+        > // if device
+      > // if host
+{
+}; // end iterator_category_to_system
+
+
+template<typename CategoryOrTraversal>
+  struct iterator_category_or_traversal_to_system
+    : eval_if<
+        is_iterator_system<CategoryOrTraversal>::value,
+        detail::identity_<CategoryOrTraversal>,
+        iterator_category_to_system<CategoryOrTraversal>
+      >
+{
+}; // end iterator_category_or_traversal_to_system
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_traversal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_traversal.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8c736c50a4ac4e441668bdaef9d5997201b6877
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_to_traversal.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>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/iterator_category_to_system.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// forward declarations
+template <typename> struct is_iterator_system;
+template <typename> struct is_iterator_traversal;
+
+template <typename Category>
+  struct host_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_host_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_host_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_host_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_host_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_host_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end host_system_category_to_traversal
+
+
+
+template <typename Category>
+  struct device_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_device_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_device_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_device_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_device_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_device_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end device_system_category_to_traversal
+
+
+template<typename Category>
+  struct category_to_traversal
+      // check for host system
+    : eval_if<
+        or_<
+          is_convertible<Category, thrust::input_host_iterator_tag>,
+          is_convertible<Category, thrust::output_host_iterator_tag>
+        >::value,
+
+        host_system_category_to_traversal<Category>,
+
+        // check for device system
+        eval_if<
+          or_<
+            is_convertible<Category, thrust::input_device_iterator_tag>,
+            is_convertible<Category, thrust::output_device_iterator_tag>
+          >::value,
+
+          device_system_category_to_traversal<Category>,
+
+          // unknown category
+          detail::identity_<void>
+        >
+      >
+{};
+
+
+template <typename CategoryOrTraversal>
+  struct iterator_category_to_traversal
+    : eval_if<
+        is_iterator_traversal<CategoryOrTraversal>::value,
+        detail::identity_<CategoryOrTraversal>,
+        category_to_traversal<CategoryOrTraversal>
+      >
+{
+}; // end iterator_category_to_traversal
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_with_system_and_traversal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_with_system_and_traversal.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdd8a6d366a0052ab71b72362b85c9af6248a784
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_category_with_system_and_traversal.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>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Category, typename System, typename Traversal>
+  struct iterator_category_with_system_and_traversal
+    : Category
+{
+}; // end iterator_category_with_system_and_traversal
+
+
+// specialize iterator_category_to_system for iterator_category_with_system_and_traversal
+template<typename Category> struct iterator_category_to_system;
+
+template<typename Category, typename System, typename Traversal>
+  struct iterator_category_to_system<iterator_category_with_system_and_traversal<Category,System,Traversal> >
+{
+  typedef System type;
+}; // end iterator_category_to_system
+
+
+// specialize iterator_category_to_traversal for iterator_category_with_system_and_traversal
+template<typename Category> struct iterator_category_to_traversal;
+
+template<typename Category, typename System, typename Traversal>
+  struct iterator_category_to_traversal<iterator_category_with_system_and_traversal<Category,System,Traversal> >
+{
+  typedef Traversal type;
+}; // end iterator_category_to_traversal
+
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_facade_category.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_facade_category.h
new file mode 100644
index 0000000000000000000000000000000000000000..81b518002baa116c41c9c2c270beafee3ac6d016
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_facade_category.h
@@ -0,0 +1,252 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/host_system_tag.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/is_iterator_category.h>
+#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
+#include <thrust/iterator/detail/iterator_category_to_traversal.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+
+// adapted from http://www.boost.org/doc/libs/1_37_0/libs/iterator/doc/iterator_facade.html#iterator-category
+//
+// in our implementation, R need not be a reference type to result in a category
+// derived from forward_XXX_iterator_tag
+//
+// iterator-category(T,V,R) :=
+//   if(T is convertible to input_host_iterator_tag
+//      || T is convertible to output_host_iterator_tag
+//      || T is convertible to input_device_iterator_tag
+//      || T is convertible to output_device_iterator_tag
+//   )
+//     return T
+//
+//   else if (T is not convertible to incrementable_traversal_tag)
+//     the program is ill-formed
+//
+//   else return a type X satisfying the following two constraints:
+//
+//     1. X is convertible to X1, and not to any more-derived
+//        type, where X1 is defined by:
+//
+//        if (T is convertible to forward_traversal_tag)
+//        {
+//          if (T is convertible to random_access_traversal_tag)
+//            X1 = random_access_host_iterator_tag
+//          else if (T is convertible to bidirectional_traversal_tag)
+//            X1 = bidirectional_host_iterator_tag
+//          else
+//            X1 = forward_host_iterator_tag
+//        }
+//        else
+//        {
+//          if (T is convertible to single_pass_traversal_tag
+//              && R is convertible to V)
+//            X1 = input_host_iterator_tag
+//          else
+//            X1 = T
+//        }
+//
+//     2. category-to-traversal(X) is convertible to the most
+//        derived traversal tag type to which X is also convertible,
+//        and not to any more-derived traversal tag type.
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category;
+
+
+// Thrust's implementation of iterator_facade_default_category is slightly
+// different from Boost's equivalent.
+// Thrust does not check is_convertible<Reference, ValueParam> because Reference
+// may not be a complete type at this point, and implementations of is_convertible
+// typically require that both types be complete.
+// Instead, it simply assumes that if is_convertible<Traversal, single_pass_traversal_tag>,
+// then the category is input_iterator_tag
+
+
+// this is the function for standard system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_std :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<std::random_access_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<std::bidirectional_iterator_tag>,
+          thrust::detail::identity_<std::forward_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if< // XXX note we differ from Boost here
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
+        thrust::detail::identity_<std::input_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_std
+
+
+// this is the function for host system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_host :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<thrust::random_access_host_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<thrust::bidirectional_host_iterator_tag>,
+          thrust::detail::identity_<thrust::forward_host_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if< // XXX note we differ from Boost here
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value,
+        thrust::detail::identity_<thrust::input_host_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_host
+
+
+// this is the function for device system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_device :
+    thrust::detail::eval_if<
+      thrust::detail::is_convertible<Traversal, thrust::forward_traversal_tag>::value,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::random_access_traversal_tag>::value,
+        thrust::detail::identity_<thrust::random_access_device_iterator_tag>,
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<Traversal, thrust::bidirectional_traversal_tag>::value,
+          thrust::detail::identity_<thrust::bidirectional_device_iterator_tag>,
+          thrust::detail::identity_<thrust::forward_device_iterator_tag>
+        >
+      >,
+      thrust::detail::eval_if<
+        thrust::detail::is_convertible<Traversal, thrust::single_pass_traversal_tag>::value, // XXX note we differ from Boost here
+        thrust::detail::identity_<thrust::input_device_iterator_tag>,
+        thrust::detail::identity_<Traversal>
+      >
+    >
+{
+}; // end iterator_facade_default_category_device
+
+
+// this is the function for any system iterators
+template<typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category_any
+{
+  typedef thrust::detail::iterator_category_with_system_and_traversal<
+    typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
+    thrust::any_system_tag,
+    Traversal
+  > type;
+}; // end iterator_facade_default_category_any
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_default_category
+      // check for any system
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::any_system_tag>::value,
+        iterator_facade_default_category_any<Traversal, ValueParam, Reference>,
+
+        // check for host system
+        thrust::detail::eval_if<
+          thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+          iterator_facade_default_category_host<Traversal, ValueParam, Reference>,
+
+          // check for device system
+          thrust::detail::eval_if<
+            thrust::detail::is_convertible<System, thrust::device_system_tag>::value,
+            iterator_facade_default_category_device<Traversal, ValueParam, Reference>,
+
+            // if we don't recognize the system, get a standard iterator category
+            // and combine it with System & Traversal
+            thrust::detail::identity_<
+              thrust::detail::iterator_category_with_system_and_traversal<
+                typename iterator_facade_default_category_std<Traversal, ValueParam, Reference>::type,
+                System,
+                Traversal
+              >
+            >
+          >
+        >
+      >
+{};
+
+
+template<typename System, typename Traversal, typename ValueParam, typename Reference>
+  struct iterator_facade_category_impl
+{
+  typedef typename iterator_facade_default_category<
+    System,Traversal,ValueParam,Reference
+  >::type category;
+
+  // we must be able to deduce both Traversal & System from category
+  // otherwise, munge them all together
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::and_<
+      thrust::detail::is_same<
+        Traversal,
+        typename thrust::detail::iterator_category_to_traversal<category>::type
+      >,
+      thrust::detail::is_same<
+        System,
+        typename thrust::detail::iterator_category_to_system<category>::type
+      >
+    >::value,
+    thrust::detail::identity_<category>,
+    thrust::detail::identity_<thrust::detail::iterator_category_with_system_and_traversal<category,System,Traversal> >
+  >::type type;
+}; // end iterator_facade_category_impl
+
+
+template<typename CategoryOrSystem,
+         typename CategoryOrTraversal,
+         typename ValueParam,
+         typename Reference>
+  struct iterator_facade_category
+{
+  typedef typename
+  thrust::detail::eval_if<
+    thrust::detail::is_iterator_category<CategoryOrTraversal>::value,
+    thrust::detail::identity_<CategoryOrTraversal>, // categories are fine as-is
+    iterator_facade_category_impl<CategoryOrSystem, CategoryOrTraversal, ValueParam, Reference>
+  >::type type;
+}; // end iterator_facade_category
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traits.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traits.inl
new file mode 100644
index 0000000000000000000000000000000000000000..544c24f0b426e423823559d69d53d7d5b62f82f2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traits.inl
@@ -0,0 +1,136 @@
+/*
+ *  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>
+
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_category_to_traversal.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/type_traits/void_t.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename Iterator>
+  struct iterator_value
+{
+  typedef typename thrust::iterator_traits<Iterator>::value_type type;
+}; // end iterator_value
+
+template <typename Iterator>
+using iterator_value_t = typename iterator_value<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_pointer
+{
+  typedef typename thrust::iterator_traits<Iterator>::pointer type;
+}; // end iterator_pointer
+
+template <typename Iterator>
+using iterator_pointer_t = typename iterator_pointer<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_reference
+{
+  typedef typename iterator_traits<Iterator>::reference type;
+}; // end iterator_reference
+
+template <typename Iterator>
+using iterator_reference_t = typename iterator_reference<Iterator>::type;
+
+template<typename Iterator>
+  struct iterator_difference
+{
+  typedef typename thrust::iterator_traits<Iterator>::difference_type type;
+}; // end iterator_difference
+
+template <typename Iterator>
+using iterator_difference_t = typename iterator_difference<Iterator>::type;
+
+namespace detail
+{
+
+template <typename Iterator, typename = void>
+struct iterator_system_impl {};
+
+template <typename Iterator>
+struct iterator_system_impl<
+  Iterator
+, typename voider<
+    typename iterator_traits<Iterator>::iterator_category
+  >::type
+>
+  : detail::iterator_category_to_system<
+      typename iterator_traits<Iterator>::iterator_category
+    >
+{};
+
+} // namespace detail
+
+template <typename Iterator>
+struct iterator_system : detail::iterator_system_impl<Iterator> {};
+
+// specialize iterator_system for void *, which has no category
+template<>
+  struct iterator_system<void *>
+{
+  typedef thrust::iterator_system<int*>::type type;
+}; // end iterator_system<void*>
+
+template<>
+  struct iterator_system<const void *>
+{
+  typedef thrust::iterator_system<const int*>::type type;
+}; // end iterator_system<void*>
+
+template <typename Iterator>
+using iterator_system_t = typename iterator_system<Iterator>::type;
+
+template <typename Iterator>
+  struct iterator_traversal
+    : detail::iterator_category_to_traversal<
+        typename thrust::iterator_traits<Iterator>::iterator_category
+      >
+{
+}; // end iterator_traversal
+
+namespace detail
+{
+
+template <typename T>
+  struct is_iterator_traversal
+    : thrust::detail::is_convertible<T, incrementable_traversal_tag>
+{
+}; // end is_iterator_traversal
+
+
+template<typename T>
+  struct is_iterator_system
+    : detail::or_<
+        detail::is_convertible<T, any_system_tag>,
+        detail::or_<
+          detail::is_convertible<T, host_system_tag>,
+          detail::is_convertible<T, device_system_tag>
+        >
+      >
+{
+}; // end is_iterator_system
+
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traversal_tags.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traversal_tags.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fbc8a1e49c00da4178dd7e893593d12de6ac250
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/iterator_traversal_tags.h
@@ -0,0 +1,42 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+// define Boost's traversal tags
+struct no_traversal_tag {};
+
+struct incrementable_traversal_tag
+  : no_traversal_tag {};
+
+struct single_pass_traversal_tag
+  : incrementable_traversal_tag {};
+
+struct forward_traversal_tag
+  : single_pass_traversal_tag {};
+
+struct bidirectional_traversal_tag
+  : forward_traversal_tag {};
+
+struct random_access_traversal_tag
+  : bidirectional_traversal_tag {};
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/join_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/join_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..83f143dc00a6a6fd504cf35726e01faed0085579
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/join_iterator.h
@@ -0,0 +1,133 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/detail/type_traits.h>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename Difference,
+         typename Reference>
+class join_iterator;
+
+
+namespace join_iterator_detail
+{
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename Difference,
+         typename Reference>
+struct join_iterator_base
+{
+  typedef typename thrust::detail::remove_reference<Reference>::type value_type;
+
+  typedef typename thrust::iterator_system<RandomAccessIterator1>::type  system1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type  system2;
+  typedef typename thrust::detail::minimum_system<system1,system2>::type system;
+
+  typedef thrust::iterator_adaptor<
+    join_iterator<RandomAccessIterator1,RandomAccessIterator2,Difference,Reference>,
+    thrust::counting_iterator<Difference>,
+    value_type,
+    system,
+    thrust::random_access_traversal_tag,
+    Reference,
+    Difference
+  > type;
+}; // end join_iterator_base
+
+
+} // end join_iterator_detail
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename Difference = typename thrust::iterator_difference<RandomAccessIterator1>::type,
+         typename Reference  = typename thrust::iterator_value<RandomAccessIterator1>::type>
+class join_iterator
+  : public join_iterator_detail::join_iterator_base<RandomAccessIterator1, RandomAccessIterator2, Difference, Reference>::type
+{
+  private:
+    typedef typename join_iterator_detail::join_iterator_base<RandomAccessIterator1, RandomAccessIterator2, Difference, Reference>::type super_t;
+    typedef typename super_t::difference_type size_type;
+
+  public:
+    inline __host__ __device__
+    join_iterator(RandomAccessIterator1 first1, size_type n, RandomAccessIterator2 first2)
+      : super_t(thrust::counting_iterator<size_type>(0)),
+        m_n1(n),
+        m_iter1(first1),
+        m_iter2(first2 - m_n1)
+    {}
+
+
+    inline __host__ __device__
+    join_iterator(const join_iterator &other)
+      : super_t(other),
+        m_n1(other.m_n1),
+        m_iter1(other.m_iter1),
+        m_iter2(other.m_iter2)
+    {}
+
+
+  private:
+    friend class thrust::iterator_core_access;
+
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      size_type i = *super_t::base();
+      return (i < m_n1) ? m_iter1[i] : static_cast<typename super_t::reference>(m_iter2[i]);
+    } // end dereference()
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+
+    size_type m_n1;
+    RandomAccessIterator1 m_iter1;
+    RandomAccessIterator2 m_iter2;
+}; // end join_iterator
+
+
+template<typename RandomAccessIterator1, typename Size, typename RandomAccessIterator2>
+__host__ __device__
+join_iterator<RandomAccessIterator1,RandomAccessIterator2,Size> make_join_iterator(RandomAccessIterator1 first1, Size n1, RandomAccessIterator2 first2)
+{
+  return join_iterator<RandomAccessIterator1,RandomAccessIterator2,Size>(first1, n1, first2);
+} // end make_join_iterator()
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_category.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_category.h
new file mode 100644
index 0000000000000000000000000000000000000000..01e7e82c5358672a8a6631596c48981eeaaa2b1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_category.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>
+
+#include <thrust/detail/type_traits/minimum_type.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{ 
+
+template<typename T1,
+         typename T2  = minimum_type_detail::any_conversion,
+         typename T3  = minimum_type_detail::any_conversion,
+         typename T4  = minimum_type_detail::any_conversion,
+         typename T5  = minimum_type_detail::any_conversion,
+         typename T6  = minimum_type_detail::any_conversion,
+         typename T7  = minimum_type_detail::any_conversion,
+         typename T8  = minimum_type_detail::any_conversion,
+         typename T9  = minimum_type_detail::any_conversion,
+         typename T10 = minimum_type_detail::any_conversion,
+         typename T11 = minimum_type_detail::any_conversion,
+         typename T12 = minimum_type_detail::any_conversion,
+         typename T13 = minimum_type_detail::any_conversion,
+         typename T14 = minimum_type_detail::any_conversion,
+         typename T15 = minimum_type_detail::any_conversion,
+         typename T16 = minimum_type_detail::any_conversion>
+  struct minimum_category
+    : minimum_type<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+{
+}; // end minimum_category
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..dcb29ccd254bb4be29d785c485fe6487f9908b3d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/minimum_system.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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/is_metafunction_defined.h>
+#include <thrust/detail/type_traits/minimum_type.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{ 
+
+
+template<typename T1,
+         typename T2  = void,
+         typename T3  = void,
+         typename T4  = void,
+         typename T5  = void,
+         typename T6  = void,
+         typename T7  = void,
+         typename T8  = void,
+         typename T9  = void,
+         typename T10 = void,
+         typename T11 = void,
+         typename T12 = void,
+         typename T13 = void,
+         typename T14 = void,
+         typename T15 = void,
+         typename T16 = void>
+  struct unrelated_systems {};
+
+
+// if a minimum system exists for these arguments, return it
+// otherwise, collect the arguments and report them as unrelated
+template<typename T1,
+         typename T2  = minimum_type_detail::any_conversion,
+         typename T3  = minimum_type_detail::any_conversion,
+         typename T4  = minimum_type_detail::any_conversion,
+         typename T5  = minimum_type_detail::any_conversion,
+         typename T6  = minimum_type_detail::any_conversion,
+         typename T7  = minimum_type_detail::any_conversion,
+         typename T8  = minimum_type_detail::any_conversion,
+         typename T9  = minimum_type_detail::any_conversion,
+         typename T10 = minimum_type_detail::any_conversion,
+         typename T11 = minimum_type_detail::any_conversion,
+         typename T12 = minimum_type_detail::any_conversion,
+         typename T13 = minimum_type_detail::any_conversion,
+         typename T14 = minimum_type_detail::any_conversion,
+         typename T15 = minimum_type_detail::any_conversion,
+         typename T16 = minimum_type_detail::any_conversion>
+  struct minimum_system
+    : thrust::detail::eval_if<
+        is_metafunction_defined<
+          minimum_type<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+        >::value,
+        minimum_type<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>,
+        thrust::detail::identity_<
+          unrelated_systems<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+        >
+      >
+{}; // end minimum_system
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/normal_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/normal_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb5d336044fb4de86eba50439ee7e4af4024e2a8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/normal_iterator.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.
+ */
+
+
+/*! \file normal_iterator.h
+ *  \brief Defines the interface to an iterator class
+ *         which adapts a pointer type.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Pointer>
+  class normal_iterator
+    : public iterator_adaptor<
+        normal_iterator<Pointer>,
+        Pointer
+      >
+{
+  typedef iterator_adaptor<normal_iterator<Pointer>, Pointer> super_t;
+
+  public:
+    __host__ __device__
+    normal_iterator() {}
+
+    __host__ __device__
+    normal_iterator(Pointer p)
+      : super_t(p) {}
+    
+    template<typename OtherPointer>
+    __host__ __device__
+    normal_iterator(const normal_iterator<OtherPointer> &other,
+                    typename thrust::detail::enable_if_convertible<
+                      OtherPointer,
+                      Pointer
+                    >::type * = 0)
+      : super_t(other.base()) {}
+
+}; // end normal_iterator
+
+
+template<typename Pointer>
+  inline __host__ __device__ normal_iterator<Pointer> make_normal_iterator(Pointer ptr)
+{
+  return normal_iterator<Pointer>(ptr);
+}
+
+} // end detail
+
+template <typename T>
+struct proclaim_contiguous_iterator<
+  thrust::detail::normal_iterator<T>
+> : true_type {};
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/permutation_iterator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/permutation_iterator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..d586cabb780266d12d4fb50aaf76932c5369003b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/permutation_iterator_base.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename,typename> class permutation_iterator;
+
+
+namespace detail
+{
+
+template<typename ElementIterator,
+         typename IndexIterator>
+  struct permutation_iterator_base
+{
+  typedef typename thrust::iterator_system<ElementIterator>::type System1;
+  typedef typename thrust::iterator_system<IndexIterator>::type System2;
+
+  typedef thrust::iterator_adaptor<
+    permutation_iterator<ElementIterator,IndexIterator>,
+    IndexIterator,
+    typename thrust::iterator_value<ElementIterator>::type,
+    typename detail::minimum_system<System1,System2>::type,
+    thrust::use_default,
+    typename thrust::iterator_reference<ElementIterator>::type
+  > type;
+}; // end permutation_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/retag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/retag.h
new file mode 100644
index 0000000000000000000000000000000000000000..d277d8b6f2b884e0fdab608e21b15755f2840859
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/retag.h
@@ -0,0 +1,147 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tagged_iterator.h>
+#include <thrust/detail/pointer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// we can retag an iterator if FromTag converts to ToTag
+// or vice versa
+template<typename FromTag, typename ToTag>
+  struct is_retaggable
+    : integral_constant<
+        bool,
+        (is_convertible<FromTag,ToTag>::value || is_convertible<ToTag,FromTag>::value)
+      >
+{};
+
+
+template<typename FromTag, typename ToTag, typename Result>
+  struct enable_if_retaggable
+    : enable_if<
+        is_retaggable<FromTag,ToTag>::value,
+        Result
+      >
+{}; // end enable_if_retaggable
+
+
+} // end detail
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  thrust::detail::tagged_iterator<Iterator,Tag>
+    reinterpret_tag(Iterator iter)
+{
+  return thrust::detail::tagged_iterator<Iterator,Tag>(iter);
+} // end reinterpret_tag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(T *ptr)
+{
+  return thrust::pointer<T,Tag>(ptr);
+} // end reinterpret_tag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag, typename Reference, typename Derived>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(thrust::pointer<T,OtherTag,Reference,Derived> ptr)
+{
+  return reinterpret_tag<Tag>(ptr.get());
+} // end reinterpret_tag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  thrust::detail::tagged_iterator<BaseIterator,Tag>
+    reinterpret_tag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter.base());
+} // end reinterpret_tag()
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<Iterator>::type,
+    Tag,
+    thrust::detail::tagged_iterator<Iterator,Tag>
+  >::type
+    retag(Iterator iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<T*>::type,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(T *ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(thrust::pointer<T,OtherTag> ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::detail::tagged_iterator<BaseIterator,Tag>
+  >::type
+    retag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..9182ac3e896773e7bcd77a6d9246e2947612b02c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator.inl
@@ -0,0 +1,118 @@
+/*
+ *  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>
+
+#include <thrust/iterator/reverse_iterator.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template<typename Iterator>
+  __host__ __device__
+  Iterator prior(Iterator x)
+{
+  return --x;
+} // end prior()
+
+} // end detail
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  reverse_iterator<BidirectionalIterator>
+    ::reverse_iterator(BidirectionalIterator x)
+      :super_t(x)
+{
+} // end reverse_iterator::reverse_iterator()
+
+template<typename BidirectionalIterator>
+  template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    reverse_iterator<BidirectionalIterator>
+      ::reverse_iterator(reverse_iterator<OtherBidirectionalIterator> const &r
+// XXX msvc screws this up
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     , typename thrust::detail::enable_if<
+                         thrust::detail::is_convertible<
+                           OtherBidirectionalIterator,
+                           BidirectionalIterator
+                         >::value
+                       >::type *
+#endif // MSVC
+                     )
+        :super_t(r.base())
+{
+} // end reverse_iterator::reverse_iterator()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  typename reverse_iterator<BidirectionalIterator>::super_t::reference
+    reverse_iterator<BidirectionalIterator>
+      ::dereference() const
+{
+  return *thrust::detail::prior(this->base());
+} // end reverse_iterator::increment()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::increment()
+{
+  --this->base_reference();
+} // end reverse_iterator::increment()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::decrement()
+{
+  ++this->base_reference();
+} // end reverse_iterator::decrement()
+
+template<typename BidirectionalIterator>
+  __host__ __device__
+  void reverse_iterator<BidirectionalIterator>
+    ::advance(typename super_t::difference_type n)
+{
+  this->base_reference() += -n;
+} // end reverse_iterator::advance()
+
+template<typename BidirectionalIterator>
+  template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    typename reverse_iterator<BidirectionalIterator>::super_t::difference_type
+      reverse_iterator<BidirectionalIterator>
+        ::distance_to(reverse_iterator<OtherBidirectionalIterator> const &y) const
+{
+  return this->base_reference() - y.base();
+} // end reverse_iterator::distance_to()
+
+template<typename BidirectionalIterator>
+__host__ __device__
+reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+{
+  return reverse_iterator<BidirectionalIterator>(x);
+} // end make_reverse_iterator()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..de3bafde979f9ed56fc80941cca6644e83e6b347
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/reverse_iterator_base.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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename> class reverse_iterator;
+
+namespace detail
+{
+
+template<typename BidirectionalIterator>
+  struct reverse_iterator_base
+{
+  typedef thrust::iterator_adaptor<
+    thrust::reverse_iterator<BidirectionalIterator>,
+    BidirectionalIterator
+  > type;
+}; // end reverse_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tagged_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tagged_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..24cbbb7361d20f5f7b6f07c622348d40bf9a648f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tagged_iterator.h
@@ -0,0 +1,85 @@
+/*
+ *  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>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename,typename> class tagged_iterator;
+
+template<typename Iterator, typename Tag>
+  struct tagged_iterator_base
+{
+  typedef thrust::iterator_adaptor<
+    tagged_iterator<Iterator,Tag>,
+    Iterator,
+    typename thrust::iterator_value<Iterator>::type,
+    Tag,
+    typename thrust::iterator_traversal<Iterator>::type,
+    typename thrust::iterator_reference<Iterator>::type,
+    typename thrust::iterator_difference<Iterator>::type
+  > type;
+}; // end tagged_iterator_base
+
+template<typename Iterator, typename Tag>
+  class tagged_iterator
+    : public tagged_iterator_base<Iterator,Tag>::type
+{
+  private:
+    typedef typename tagged_iterator_base<Iterator,Tag>::type super_t;
+
+  public:
+    __host__ __device__
+    tagged_iterator() {}
+
+    __host__ __device__
+    explicit tagged_iterator(Iterator x)
+      : super_t(x) {}
+}; // end tagged_iterator
+
+/*! \p make_tagged_iterator creates a \p tagged_iterator
+ *  from a \c Iterator with system tag \c Tag.
+ *
+ *  \tparam Tag Any system tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator whose system tag is \p Tag and whose behavior is otherwise
+ *          equivalent to \p iter.
+ */
+template <typename Tag, typename Iterator>
+inline auto make_tagged_iterator(Iterator iter) -> tagged_iterator<Iterator, Tag>
+{
+  return tagged_iterator<Iterator, Tag>(iter);
+}
+
+} // end detail
+
+// tagged_iterator is trivial if its base iterator is.
+template <typename BaseIterator, typename Tag>
+struct proclaim_contiguous_iterator<
+  detail::tagged_iterator<BaseIterator, Tag>
+> : is_contiguous_iterator<BaseIterator> {};
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_input_output_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_input_output_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..b4792f724df34b95cef93945d81e9b4148e3262d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_input_output_iterator.inl
@@ -0,0 +1,107 @@
+/*
+ *  Copyright 2020-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>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator;
+
+namespace detail
+{
+
+// Proxy reference that invokes InputFunction when reading from and
+// OutputFunction when writing to the dereferenced iterator
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator_proxy
+{
+  using iterator_value_type = typename thrust::iterator_value<Iterator>::type;
+
+  using Value = invoke_result_t<InputFunction, iterator_value_type>;
+
+  public:
+    __host__ __device__
+    transform_input_output_iterator_proxy(const Iterator& io, InputFunction input_function, OutputFunction output_function)
+      : io(io), input_function(input_function), output_function(output_function)
+    {
+    }
+
+    transform_input_output_iterator_proxy(const transform_input_output_iterator_proxy&) = default;
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    operator Value const() const
+    {
+      return input_function(*io);
+    }
+
+    __thrust_exec_check_disable__
+    template <typename T>
+    __host__ __device__
+    transform_input_output_iterator_proxy operator=(const T& x)
+    {
+      *io = output_function(x);
+      return *this;
+    }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    transform_input_output_iterator_proxy operator=(const transform_input_output_iterator_proxy& x)
+    {
+      *io = output_function(x);
+      return *this;
+    }
+
+  private:
+    Iterator io;
+    InputFunction input_function;
+    OutputFunction output_function;
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_input_output_iterator
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+struct transform_input_output_iterator_base
+{
+private:
+  using iterator_value_type = typename thrust::iterator_value<Iterator>::type;
+
+public:
+    typedef thrust::iterator_adaptor
+    <
+        transform_input_output_iterator<InputFunction, OutputFunction, Iterator>
+      , Iterator
+      , detail::invoke_result_t<InputFunction, iterator_value_type>
+      , thrust::use_default
+      , thrust::use_default
+      , transform_input_output_iterator_proxy<InputFunction, OutputFunction, Iterator>
+    > type;
+};
+
+// Register transform_input_output_iterator_proxy with 'is_proxy_reference' from
+// type_traits to enable its use with algorithms.
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+struct is_proxy_reference<
+    transform_input_output_iterator_proxy<InputFunction, OutputFunction, Iterator> >
+    : public thrust::detail::true_type {};
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..0dc6f9854de9e1c0fc817a8d7f0983767fb2e37d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_iterator.inl
@@ -0,0 +1,69 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <class UnaryFunction, class Iterator, class Reference, class Value>
+  class transform_iterator;
+
+namespace detail
+{
+
+// Compute the iterator_adaptor instantiation to be used for transform_iterator
+template <class UnaryFunc, class Iterator, class Reference, class Value>
+struct transform_iterator_base
+{
+ private:
+    // By default, dereferencing the iterator yields the same as the function.
+    typedef typename thrust::detail::ia_dflt_help<
+      Reference,
+      thrust::detail::result_of_adaptable_function<UnaryFunc(typename thrust::iterator_value<Iterator>::type)>
+    >::type reference;
+
+    // To get the default for Value: remove cvref on the result type.
+    using value_type =
+      typename thrust::detail::ia_dflt_help<Value, thrust::remove_cvref<reference>>::type;
+
+  public:
+    typedef thrust::iterator_adaptor
+    <
+        transform_iterator<UnaryFunc, Iterator, Reference, Value>
+      , Iterator
+      , value_type
+      , thrust::use_default   // Leave the system alone
+        //, thrust::use_default   // Leave the traversal alone
+        // use the Iterator's category to let any system iterators remain random access even though
+        // transform_iterator's reference type may not be a reference
+        // XXX figure out why only iterators whose reference types are true references are random access
+        , typename thrust::iterator_traits<Iterator>::iterator_category
+      , reference
+    > type;
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_output_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_output_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..d5033f105894c024b5941291079ab575df282edd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/transform_output_iterator.inl
@@ -0,0 +1,81 @@
+/*
+ *  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>
+
+#include <thrust/iterator/transform_output_iterator.h>
+#include <thrust/iterator/iterator_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator;
+
+namespace detail
+{
+
+// Proxy reference that uses Unary Function to transform the rhs of assigment
+// operator before writing the result to OutputIterator
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator_proxy
+{
+  public:
+    __host__ __device__
+    transform_output_iterator_proxy(const OutputIterator& out, UnaryFunction fun) : out(out), fun(fun)
+    {
+    }
+
+    __thrust_exec_check_disable__
+    template <typename T>
+    __host__ __device__
+    transform_output_iterator_proxy operator=(const T& x)
+    {
+      *out = fun(x);
+      return *this;
+    }
+
+  private:
+    OutputIterator out;
+    UnaryFunction fun;
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_output_iterator
+template <typename UnaryFunction, typename OutputIterator>
+struct transform_output_iterator_base
+{
+    typedef thrust::iterator_adaptor
+    <
+        transform_output_iterator<UnaryFunction, OutputIterator>
+      , OutputIterator
+      , thrust::use_default
+      , thrust::use_default
+      , thrust::use_default
+      , transform_output_iterator_proxy<UnaryFunction, OutputIterator>
+    > type;
+};
+
+// Register transform_output_iterator_proxy with 'is_proxy_reference' from
+// type_traits to enable its use with algorithms.
+template <class UnaryFunction, class OutputIterator>
+struct is_proxy_reference<
+    transform_output_iterator_proxy<UnaryFunction, OutputIterator> >
+    : public thrust::detail::true_type {};
+
+} // end detail
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tuple_of_iterator_references.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tuple_of_iterator_references.h
new file mode 100644
index 0000000000000000000000000000000000000000..78c5e8a28f49a23b665d5ca0253295142da179ee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/tuple_of_iterator_references.h
@@ -0,0 +1,146 @@
+/*
+ *  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>
+#include <thrust/tuple.h>
+#include <thrust/pair.h>
+#include <thrust/detail/reference_forward_declaration.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+  
+template<
+  typename... Ts
+>
+  class tuple_of_iterator_references
+    : public thrust::tuple<Ts...>
+{
+  private:
+    typedef thrust::tuple<Ts...> super_t;
+
+  public:
+    // allow implicit construction from tuple<refs>
+    inline __host__ __device__
+    tuple_of_iterator_references(const super_t &other)
+      : super_t(other)
+    {}
+
+    // allow assignment from tuples
+    // XXX might be worthwhile to guard this with an enable_if is_assignable
+    __thrust_exec_check_disable__
+    template<typename... Us>
+    inline __host__ __device__
+    tuple_of_iterator_references &operator=(const thrust::tuple<Us...> &other)
+    {
+      super_t::operator=(other);
+      return *this;
+    }
+
+    // allow assignment from pairs
+    // XXX might be worthwhile to guard this with an enable_if is_assignable
+    __thrust_exec_check_disable__
+    template<typename U1, typename U2>
+    inline __host__ __device__
+    tuple_of_iterator_references &operator=(const thrust::pair<U1,U2> &other)
+    {
+      super_t::operator=(other);
+      return *this;
+    }
+
+    // allow assignment from reference<tuple>
+    // XXX perhaps we should generalize to reference<T>
+    //     we could captures reference<pair> this way
+    __thrust_exec_check_disable__
+    template<typename Pointer, typename Derived,
+             typename... Us>
+    inline __host__ __device__
+// XXX gcc-4.2 crashes on is_assignable
+//    typename thrust::detail::enable_if<
+//      thrust::detail::is_assignable<
+//        super_t,
+//        const thrust::tuple<Us...>
+//      >::value,
+//      tuple_of_iterator_references &
+//    >::type
+    tuple_of_iterator_references &
+    operator=(const thrust::reference<thrust::tuple<Us...>, Pointer, Derived> &other)
+    {
+      typedef thrust::tuple<Us...> tuple_type;
+
+      // XXX perhaps this could be accelerated
+      tuple_type other_tuple = other;
+      super_t::operator=(other_tuple);
+      return *this;
+    }
+
+
+    // duplicate thrust::tuple's constructors
+    inline __host__ __device__
+    tuple_of_iterator_references() {}
+
+    inline __host__ __device__
+    tuple_of_iterator_references(typename access_traits<Ts>::parameter_type... ts)
+      : super_t(ts...)
+    {}
+};
+
+
+// this overload of swap() permits swapping tuple_of_iterator_references returned as temporaries from
+// iterator dereferences
+template<
+  typename... Ts,
+  typename... Us
+>
+inline __host__ __device__
+void swap(tuple_of_iterator_references<Ts...> x,
+          tuple_of_iterator_references<Us...> y)
+{
+  x.swap(y);
+}
+
+
+} // end detail
+
+// define tuple_size, tuple_element, etc.
+template<class... Ts>
+struct tuple_size<detail::tuple_of_iterator_references<Ts...>>
+  : std::integral_constant<size_t, sizeof...(Ts)>
+{};
+
+template<size_t i>
+struct tuple_element<i, detail::tuple_of_iterator_references<>> {};
+
+
+template<class T, class... Ts>
+struct tuple_element<0, detail::tuple_of_iterator_references<T,Ts...>>
+{
+  using type = T;
+};
+
+
+template<size_t i, class T, class... Ts>
+struct tuple_element<i, detail::tuple_of_iterator_references<T,Ts...>>
+{
+  using type = typename tuple_element<i - 1, detail::tuple_of_iterator_references<Ts...>>::type;
+};
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/universal_categories.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/universal_categories.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2abd7f55bd7742bd927b313fb9a66bcfbf4fea9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/universal_categories.h
@@ -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>
+#include <thrust/iterator/iterator_categories.h>
+
+// XXX eliminate this file
+
+THRUST_NAMESPACE_BEGIN
+
+// define these types without inheritance to avoid ambiguous conversion to base classes
+
+struct input_universal_iterator_tag
+{
+  operator input_host_iterator_tag () {return input_host_iterator_tag();}
+
+  operator input_device_iterator_tag () {return input_device_iterator_tag();}
+};
+
+struct output_universal_iterator_tag
+{
+  operator output_host_iterator_tag () {return output_host_iterator_tag();}
+
+  operator output_device_iterator_tag () {return output_device_iterator_tag();}
+};
+
+struct forward_universal_iterator_tag
+  : input_universal_iterator_tag
+{
+  operator forward_host_iterator_tag () {return forward_host_iterator_tag();};
+
+  operator forward_device_iterator_tag () {return forward_device_iterator_tag();};
+};
+
+struct bidirectional_universal_iterator_tag
+  : forward_universal_iterator_tag
+{
+  operator bidirectional_host_iterator_tag () {return bidirectional_host_iterator_tag();};
+
+  operator bidirectional_device_iterator_tag () {return bidirectional_device_iterator_tag();};
+};
+
+
+namespace detail
+{
+
+// create this struct to control conversion precedence in random_access_universal_iterator_tag
+template<typename T>
+struct one_degree_of_separation
+  : T
+{
+};
+
+} // end detail
+
+
+struct random_access_universal_iterator_tag
+{
+  // these conversions are all P0
+  operator random_access_host_iterator_tag () {return random_access_host_iterator_tag();};
+
+  operator random_access_device_iterator_tag () {return random_access_device_iterator_tag();};
+
+  // bidirectional_universal_iterator_tag is P1
+  operator detail::one_degree_of_separation<bidirectional_universal_iterator_tag> () {return detail::one_degree_of_separation<bidirectional_universal_iterator_tag>();}
+
+};
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator.inl
new file mode 100644
index 0000000000000000000000000000000000000000..a2bc98afec2e83438f97a1f2a15de679176fa93c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator.inl
@@ -0,0 +1,152 @@
+/*
+ *  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>
+
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/detail/tuple_transform.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  zip_iterator<IteratorTuple>
+    ::zip_iterator()
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  zip_iterator<IteratorTuple>
+    ::zip_iterator(IteratorTuple iterator_tuple)
+      :m_iterator_tuple(iterator_tuple)
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+  template<typename OtherIteratorTuple>
+  __host__ __device__
+    zip_iterator<IteratorTuple>
+      ::zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
+                     typename thrust::detail::enable_if_convertible<
+                       OtherIteratorTuple,
+                       IteratorTuple
+                     >::type *)
+        :m_iterator_tuple(other.get_iterator_tuple())
+{
+} // end zip_iterator::zip_iterator()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+const IteratorTuple &zip_iterator<IteratorTuple>
+  ::get_iterator_tuple() const
+{
+  return m_iterator_tuple;
+} // end zip_iterator::get_iterator_tuple()
+
+
+template<typename IteratorTuple>
+  typename zip_iterator<IteratorTuple>::super_t::reference
+  __host__ __device__
+    zip_iterator<IteratorTuple>
+      ::dereference() const
+{
+  using namespace detail::tuple_impl_specific;
+
+  return thrust::detail::tuple_host_device_transform<
+    detail::dereference_iterator::template apply
+  >(get_iterator_tuple(), detail::dereference_iterator());
+} // end zip_iterator::dereference()
+
+
+__thrust_exec_check_disable__
+template<typename IteratorTuple>
+  template<typename OtherIteratorTuple>
+  __host__ __device__
+    bool zip_iterator<IteratorTuple>
+      ::equal(const zip_iterator<OtherIteratorTuple> &other) const
+{
+  return get<0>(get_iterator_tuple()) == get<0>(other.get_iterator_tuple());
+} // end zip_iterator::equal()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::advance(typename super_t::difference_type n)
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple,
+                 detail::advance_iterator<typename super_t::difference_type>(n));
+} // end zip_iterator::advance()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::increment()
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple, detail::increment_iterator());
+} // end zip_iterator::increment()
+
+
+template<typename IteratorTuple>
+__host__ __device__
+  void zip_iterator<IteratorTuple>
+    ::decrement()
+{
+  using namespace detail::tuple_impl_specific;
+  tuple_for_each(m_iterator_tuple, detail::decrement_iterator());
+} // end zip_iterator::decrement()
+
+
+__thrust_exec_check_disable__
+template<typename IteratorTuple>
+  template <typename OtherIteratorTuple>
+  __host__ __device__
+    typename zip_iterator<IteratorTuple>::super_t::difference_type
+      zip_iterator<IteratorTuple>
+        ::distance_to(const zip_iterator<OtherIteratorTuple> &other) const
+{
+  return get<0>(other.get_iterator_tuple()) - get<0>(get_iterator_tuple());
+} // end zip_iterator::distance_to()
+
+
+template<typename... Iterators>
+__host__ __device__
+  zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(thrust::tuple<Iterators...> t)
+{
+  return zip_iterator<thrust::tuple<Iterators...>>(t);
+} // end make_zip_iterator()
+
+
+template<typename... Iterators>
+__host__ __device__
+  zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(Iterators... its)
+{
+  return make_zip_iterator(thrust::make_tuple(its...));
+} // end make_zip_iterator()
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..030153b65eae174a8815f8513ff180a11300c481
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/detail/zip_iterator_base.h
@@ -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>
+
+#include <thrust/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/minimum_category.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/type_traits/integer_sequence.h>
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+#include <thrust/detail/tuple_transform.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declare zip_iterator for zip_iterator_base
+template<typename IteratorTuple> class zip_iterator;
+
+namespace detail
+{
+
+
+// Functors to be used with tuple algorithms
+//
+template<typename DiffType>
+class advance_iterator
+{
+public:
+  inline __host__ __device__
+  advance_iterator(DiffType step) : m_step(step) {}
+
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it) const
+  { thrust::advance(it, m_step); }
+
+private:
+  DiffType m_step;
+}; // end advance_iterator
+
+
+struct increment_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { ++it; }
+}; // end increment_iterator
+
+
+struct decrement_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { --it; }
+}; // end decrement_iterator
+
+
+struct dereference_iterator
+{
+  template<typename Iterator>
+  struct apply
+  { 
+    typedef typename
+      iterator_traits<Iterator>::reference
+    type;
+  }; // end apply
+
+  // XXX silence warnings of the form "calling a __host__ function from a __host__ __device__ function is not allowed
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  __host__ __device__
+    typename apply<Iterator>::type operator()(Iterator const& it)
+  {
+    return *it;
+  }
+}; // end dereference_iterator
+
+
+// The namespace tuple_impl_specific provides two meta-
+// algorithms and two algorithms for tuples.
+namespace tuple_impl_specific
+{
+
+// define apply1 for tuple_meta_transform_impl
+template<typename UnaryMetaFunctionClass, class Arg>
+  struct apply1
+    : UnaryMetaFunctionClass::template apply<Arg>
+{
+}; // end apply1
+
+
+// define apply2 for tuple_meta_accumulate_impl
+template<typename UnaryMetaFunctionClass, class Arg1, class Arg2>
+  struct apply2
+    : UnaryMetaFunctionClass::template apply<Arg1,Arg2>
+{
+}; // end apply2
+
+
+// Meta-accumulate algorithm for tuples. Note: The template 
+// parameter StartType corresponds to the initial value in 
+// ordinary accumulation.
+//
+template<class Tuple, class BinaryMetaFun, class StartType>
+  struct tuple_meta_accumulate;
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+>
+  struct tuple_meta_accumulate<thrust::tuple<>,BinaryMetaFun,StartType>
+{
+   typedef typename thrust::detail::identity_<StartType>::type type;
+};
+
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+  , typename    T
+  , typename... Ts
+>
+  struct tuple_meta_accumulate<thrust::tuple<T,Ts...>,BinaryMetaFun,StartType>
+{
+   typedef typename apply2<
+       BinaryMetaFun
+     , T
+     , typename tuple_meta_accumulate<
+           thrust::tuple<Ts...>
+         , BinaryMetaFun
+         , StartType 
+       >::type
+   >::type type;
+};
+
+
+template<typename Fun>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f)
+{
+  return f;
+}
+
+template<typename Fun, typename T, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f, T& t, Ts&... ts)
+{
+  f(t);
+  return tuple_for_each_helper(f, ts...);
+}
+
+// for_each algorithm for tuples.
+
+template<typename Fun, typename... Ts, size_t... Is>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f, thrust::index_sequence<Is...>)
+{
+  return tuple_for_each_helper(f, thrust::get<Is>(t)...);
+} // end tuple_for_each()
+
+// for_each algorithm for tuples.
+template<typename Fun, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f)
+{ 
+  return tuple_for_each(t, f, thrust::make_index_sequence<thrust::tuple_size<thrust::tuple<Ts...>>::value>{});
+}
+
+
+} // end tuple_impl_specific
+
+
+// Metafunction to obtain the type of the tuple whose element types
+// are the value_types of an iterator tupel.
+//
+template<typename IteratorTuple>
+  struct tuple_of_value_types
+    : tuple_meta_transform<
+          IteratorTuple,
+          iterator_value
+        >
+{
+}; // end tuple_of_value_types
+
+
+struct minimum_category_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_category<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal traversal tag in a tuple
+// of iterators.
+//
+template<typename IteratorTuple>
+struct minimum_traversal_category_in_iterator_tuple
+{
+  typedef typename tuple_meta_transform<
+      IteratorTuple
+    , thrust::iterator_traversal
+  >::type tuple_of_traversal_tags;
+      
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+      tuple_of_traversal_tags
+    , minimum_category_lambda
+    , thrust::random_access_traversal_tag
+  >::type type;
+};
+
+
+struct minimum_system_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_system<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal system tag in a tuple
+// of iterators.
+template<typename IteratorTuple>
+struct minimum_system_in_iterator_tuple
+{
+  typedef typename thrust::detail::tuple_meta_transform<
+    IteratorTuple,
+    thrust::iterator_system
+  >::type tuple_of_system_tags;
+
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+    tuple_of_system_tags,
+    minimum_system_lambda,
+    thrust::any_system_tag
+  >::type type;
+};
+
+namespace zip_iterator_base_ns
+{
+
+
+template<typename Tuple, typename IndexSequence>
+  struct tuple_of_iterator_references_helper;
+
+
+template<typename Tuple, size_t... Is>
+  struct tuple_of_iterator_references_helper<Tuple, thrust::index_sequence<Is...>>
+{
+  typedef thrust::detail::tuple_of_iterator_references<
+    typename thrust::tuple_element<Is,Tuple>::type...
+  > type;
+};
+
+
+template<typename IteratorTuple>
+  struct tuple_of_iterator_references
+{
+  // get a thrust::tuple of the iterators' references
+  typedef typename tuple_meta_transform<
+    IteratorTuple,
+    iterator_reference
+  >::type tuple_of_references;
+
+  // map thrust::tuple<T...> to tuple_of_iterator_references<T...>
+  typedef typename tuple_of_iterator_references_helper<
+    tuple_of_references,
+    thrust::make_index_sequence<thrust::tuple_size<tuple_of_references>::value>
+  >::type type;
+};
+
+
+} // end zip_iterator_base_ns
+
+///////////////////////////////////////////////////////////////////
+//
+// Class zip_iterator_base
+//
+// Builds and exposes the iterator facade type from which the zip 
+// iterator will be derived.
+//
+template<typename IteratorTuple>
+  struct zip_iterator_base
+{
+ //private:
+    // reference type is the type of the tuple obtained from the
+    // iterators' reference types.
+    typedef typename zip_iterator_base_ns::tuple_of_iterator_references<IteratorTuple>::type reference;
+
+    // Boost's Value type is the same as reference type.
+    //typedef reference value_type;
+    typedef typename tuple_of_value_types<IteratorTuple>::type value_type;
+
+    // Difference type is the first iterator's difference type
+    typedef typename thrust::iterator_traits<
+      typename thrust::tuple_element<0, IteratorTuple>::type
+    >::difference_type difference_type;
+
+    // Iterator system is the minimum system tag in the
+    // iterator tuple
+    typedef typename
+    minimum_system_in_iterator_tuple<IteratorTuple>::type system;
+
+    // Traversal category is the minimum traversal category in the
+    // iterator tuple
+    typedef typename
+    minimum_traversal_category_in_iterator_tuple<IteratorTuple>::type traversal_category;
+  
+ public:
+  
+    // The iterator facade type from which the zip iterator will
+    // be derived.
+    typedef thrust::iterator_facade<
+        zip_iterator<IteratorTuple>,
+        value_type,  
+        system,
+        traversal_category,
+        reference,
+        difference_type
+    > type;
+}; // end zip_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/discard_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/discard_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb5156edac4ad0a43cfcfb2ac0af70e2aac93f9c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/discard_iterator.h
@@ -0,0 +1,174 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/discard_iterator.h
+ *  \brief An iterator which "discards" (ignores) values assigned to it upon dereference
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/discard_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p discard_iterator is an iterator which represents a special kind of pointer that
+ *  ignores values written to it upon dereference. This iterator is useful for ignoring
+ *  the output of certain algorithms without wasting memory capacity or bandwidth.
+ *  \p discard_iterator may also be used to count the size of an algorithm's output which
+ *  may not be known a priori.
+ *
+ *  The following code snippet demonstrates how to use \p discard_iterator to ignore
+ *  ignore one of the output ranges of reduce_by_key
+ *
+ *  \code
+ *  #include <thrust/iterator/discard_iterator.h>
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> keys(7), values(7);
+ *
+ *    keys[0] = 1;
+ *    keys[1] = 3;
+ *    keys[2] = 3;
+ *    keys[3] = 3;
+ *    keys[4] = 2;
+ *    keys[5] = 2;
+ *    keys[6] = 1;
+ *
+ *    values[0] = 9;
+ *    values[1] = 8;
+ *    values[2] = 7;
+ *    values[3] = 6;
+ *    values[4] = 5;
+ *    values[5] = 4;
+ *    values[6] = 3;
+ *
+ *    thrust::device_vector<int> result(4);
+ *
+ *    // we are only interested in the reduced values
+ *    // use discard_iterator to ignore the output keys
+ *    thrust::reduce_by_key(keys.begin(), keys.end(),
+ *                          values.begin(),
+ *                          thrust::make_discard_iterator(),
+ *                          result.begin());
+ *
+ *    // result is now [9, 21, 9, 3]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_discard_iterator
+ */
+template<typename System = use_default>
+  class discard_iterator
+    : public detail::discard_iterator_base<System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::discard_iterator_base<System>::type          super_t;
+    typedef typename detail::discard_iterator_base<System>::incrementable incrementable;
+    typedef typename detail::discard_iterator_base<System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Copy constructor copies from a source discard_iterator.
+     *
+     *  \p rhs The discard_iterator to copy.
+     */
+    __host__ __device__
+    discard_iterator(discard_iterator const &rhs)
+      : super_t(rhs.base()) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    discard_iterator & operator=(const discard_iterator &) = default;
+#endif
+
+    /*! This constructor receives an optional index specifying the position of this
+     *  \p discard_iterator in a range.
+     *
+     *  \p i The index of this \p discard_iterator in a range. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    discard_iterator(incrementable const &i = incrementable())
+      : super_t(base_iterator(i)) {}
+
+    /*! \cond
+     */
+
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_element;
+    }
+
+    mutable value_type m_element;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! \p make_discard_iterator creates a \p discard_iterator from an optional index parameter.
+ *
+ *  \param i The index of the returned \p discard_iterator within a range.
+ *           In the default case, the value of this parameter is \c 0.
+ *
+ *  \return A new \p discard_iterator with index as given by \p i.
+ *
+ *  \see constant_iterator
+ */
+inline __host__ __device__
+discard_iterator<> make_discard_iterator(discard_iterator<>::difference_type i = discard_iterator<>::difference_type(0))
+{
+  return discard_iterator<>(i);
+} // end make_discard_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_adaptor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_adaptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..67d4866b9a55cd7abb7f93af1c068cdc49d4cf11
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_adaptor.h
@@ -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.
+ */
+
+
+/*! \file thrust/iterator/iterator_adaptor.h
+ *  \brief An iterator which adapts a base iterator
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/use_default.h>
+#include <thrust/iterator/detail/iterator_adaptor_base.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p iterator_adaptor is an iterator which adapts an existing type of iterator to create a new type of
+ *  iterator. Most of Thrust's fancy iterators are defined via inheritance from \p iterator_adaptor.
+ *  While composition of these existing Thrust iterators is often sufficient for expressing the desired
+ *  functionality, it is occasionally more straightforward to derive from \p iterator_adaptor directly.
+ *
+ *  To see how to use \p iterator_adaptor to create a novel iterator type, let's examine how to use it to
+ *  define \p repeat_iterator, a fancy iterator which repeats elements from another range a given number of time:
+ *
+ *  \code
+ *  #include <thrust/iterator/iterator_adaptor.h>
+ *
+ *  // derive repeat_iterator from iterator_adaptor
+ *  template<typename Iterator>
+ *    class repeat_iterator
+ *      : public thrust::iterator_adaptor<
+ *          repeat_iterator<Iterator>, // the first template parameter is the name of the iterator we're creating
+ *          Iterator                   // the second template parameter is the name of the iterator we're adapting
+ *                                     // we can use the default for the additional template parameters
+ *        >
+ *  {
+ *    public:
+ *      // shorthand for the name of the iterator_adaptor we're deriving from
+ *      typedef thrust::iterator_adaptor<
+ *        repeat_iterator<Iterator>,
+ *        Iterator
+ *      > super_t;
+ *
+ *      __host__ __device__
+ *      repeat_iterator(const Iterator &x, int n) : super_t(x), begin(x), n(n) {}
+ *
+ *      // befriend thrust::iterator_core_access to allow it access to the private interface below
+ *      friend class thrust::iterator_core_access;
+ *
+ *    private:
+ *      // repeat each element of the adapted range n times
+ *      unsigned int n;
+ *
+ *      // used to keep track of where we began
+ *      const Iterator begin;
+ *
+ *      // it is private because only thrust::iterator_core_access needs access to it
+ *      __host__ __device__
+ *      typename super_t::reference dereference() const
+ *      {
+ *        return *(begin + (this->base() - begin) / n);
+ *      }
+ *  };
+ *  \endcode
+ *
+ *  Except for the first two, \p iterator_adaptor's template parameters are optional. When omitted, or when the
+ *  user specifies \p thrust::use_default in its place, \p iterator_adaptor will use a default type inferred from \p Base.
+ *
+ *  \p iterator_adaptor's functionality is derived from and generally equivalent to \p boost::iterator_adaptor.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems.
+ *
+ *  \p iterator_adaptor is a powerful tool for creating custom iterators directly. However, the large set of iterator semantics which must be satisfied
+ *  for algorithm compatibility can make \p iterator_adaptor difficult to use correctly. Unless you require the full expressivity of \p iterator_adaptor,
+ *  consider building a custom iterator through composition of existing higher-level fancy iterators instead. 
+ *
+ *  Interested users may refer to <tt>boost::iterator_adaptor</tt>'s documentation for further usage examples.
+ */
+template<typename Derived,
+         typename Base,
+         typename Value      = use_default,
+         typename System     = use_default,
+         typename Traversal  = use_default,
+         typename Reference  = use_default,
+         typename Difference = use_default>
+  class iterator_adaptor:
+    public detail::iterator_adaptor_base<
+      Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type
+{
+  /*! \cond
+   */
+
+    friend class thrust::iterator_core_access;
+
+  protected:
+    typedef typename detail::iterator_adaptor_base<
+        Derived, Base, Value, System, Traversal, Reference, Difference
+    >::type super_t;
+
+  /*! \endcond
+   */
+  
+  public:
+    /*! \p iterator_adaptor's default constructor does nothing.
+     */
+    __host__ __device__
+    iterator_adaptor(){}
+
+    /*! This constructor copies from a given instance of the \p Base iterator.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit iterator_adaptor(Base const& iter)
+      : m_iterator(iter)
+    {}
+
+    /*! The type of iterator this \p iterator_adaptor's \p adapts.
+     */
+    typedef Base       base_type;
+                                                                                              
+    /*! \cond
+     */
+    typedef typename super_t::reference reference;
+                                                                                              
+    typedef typename super_t::difference_type difference_type;
+    /*! \endcond
+     */
+
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base() const
+    { return m_iterator; }
+
+  protected:
+    /*! \return A \p const reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base const& base_reference() const
+    { return m_iterator; }
+
+    /*! \return A mutable reference to the \p Base iterator this \p iterator_adaptor adapts.
+     */
+    __host__ __device__
+    Base& base_reference()
+    { return m_iterator; }
+
+    /*! \cond
+     */
+  private: // Core iterator interface for iterator_facade
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename iterator_adaptor::reference dereference() const
+    { return *m_iterator; }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& x) const
+    { return m_iterator == x.base(); }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void advance(typename iterator_adaptor::difference_type n)
+    {
+      // XXX statically assert on random_access_traversal_tag
+
+      // counting_iterator will pick eg. diff_t=int64 when base=int32.
+      // Explicitly cast to avoid static conversion warnings.
+      m_iterator = static_cast<base_type>(m_iterator + n);
+    }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void increment()
+    { ++m_iterator; }
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    void decrement()
+    {
+      // XXX statically assert on bidirectional_traversal_tag
+      --m_iterator;
+    }
+
+    __thrust_exec_check_disable__
+    template<typename OtherDerived, typename OtherIterator, typename V, typename S, typename T, typename R, typename D>
+    __host__ __device__
+    typename iterator_adaptor::difference_type distance_to(iterator_adaptor<OtherDerived, OtherIterator, V, S, T, R, D> const& y) const
+    { return y.base() - m_iterator; }
+
+  private:
+    Base m_iterator;
+
+    /*! \endcond
+     */
+}; // end iterator_adaptor
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_categories.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_categories.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a6f3f4ae5241a3e702b862f4d44c9d99717c3e2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_categories.h
@@ -0,0 +1,223 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_categories.h
+ *  \brief Types for reasoning about the categories of iterators
+ */
+
+/*
+ * (C) Copyright Jeremy Siek 2002.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/iterator_category_with_system_and_traversal.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+
+// #include this for stl's iterator tags
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \addtogroup iterator_tags Iterator Tags
+ *  \ingroup iterators
+ *  \addtogroup iterator_tag_classes Iterator Tag Classes
+ *  \ingroup iterator_tags
+ *  \{
+ */
+
+/*! \p input_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  output_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct input_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::input_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p output_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, forward_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct output_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::output_iterator_tag,
+      thrust::device_system_tag,
+      thrust::single_pass_traversal_tag
+    >
+{};
+
+/*! \p forward_device_iterator_tag is an empty class: it has no member functions,
+ *  member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Device Iterator concept within the C++ type
+ *  system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags  iterator_traits,
+ *  input_device_iterator_tag, output_device_iterator_tag,
+ *  bidirectional_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct forward_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::forward_iterator_tag,
+      thrust::device_system_tag,
+      thrust::forward_traversal_tag
+    >
+{};
+
+/*! \p bidirectional_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Bidirectional Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct bidirectional_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::bidirectional_iterator_tag,
+      thrust::device_system_tag,
+      thrust::bidirectional_traversal_tag
+    >
+{};
+
+/*! \p random_access_device_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Random Access Device Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+struct random_access_device_iterator_tag
+  : thrust::detail::iterator_category_with_system_and_traversal<
+      std::random_access_iterator_tag,
+      thrust::device_system_tag,
+      thrust::random_access_traversal_tag
+    >
+{};
+
+/*! \p input_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Input Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  output_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::input_iterator_tag input_host_iterator_tag;
+
+/*! \p output_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Output Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, forward_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::output_iterator_tag output_host_iterator_tag;
+
+/*! \p forward_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  bidirectional_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::forward_iterator_tag forward_host_iterator_tag;
+
+/*! \p bidirectional_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, random_access_host_iterator_tag
+ */
+typedef std::bidirectional_iterator_tag bidirectional_host_iterator_tag;
+
+/*! \p random_access_host_iterator_tag is an empty class: it has no member
+ *  functions, member variables, or nested types. It is used solely as a "tag": a
+ *  representation of the Forward Host Iterator concept within the C++
+ *  type system.
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/iterator_tags 
+ *  iterator_traits, input_device_iterator_tag, output_device_iterator_tag,
+ *  forward_device_iterator_tag, bidirectional_device_iterator_tag,
+ *  random_access_device_iterator_tag,
+ *  input_host_iterator_tag, output_host_iterator_tag,
+ *  forward_host_iterator_tag, bidirectional_host_iterator_tag
+ */
+typedef std::random_access_iterator_tag random_access_host_iterator_tag;
+
+/*! \} // end iterator_tag_classes
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/universal_categories.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_facade.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_facade.h
new file mode 100644
index 0000000000000000000000000000000000000000..f6920c5c85c05b72a8a4a500513a33623fb0eb25
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_facade.h
@@ -0,0 +1,542 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/iterator_facade.h
+ *  \brief A class which exposes a public interface for iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/iterator_facade_category.h>
+#include <thrust/iterator/detail/distance_from_result.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+
+// This forward declaration is required for the friend declaration
+// in iterator_core_access
+template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> class iterator_facade;
+
+
+/*! \p iterator_core_access is the class which user iterator types derived from \p thrust::iterator_adaptor
+ *  or \p thrust::iterator_facade must befriend to allow it to access their private interface.
+ */
+class iterator_core_access
+{
+    /*! \cond
+     */
+
+    // declare our friends
+    template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> friend class iterator_facade;
+
+    // iterator comparisons are our friends
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    // iterator difference is our friend
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend
+      typename thrust::detail::distance_from_result<
+        iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+        iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+      >::type
+    operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+              iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template<typename Facade>
+    __host__ __device__
+    static typename Facade::reference dereference(Facade const& f)
+    {
+      return f.dereference();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void increment(Facade& f)
+    {
+      f.increment();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void decrement(Facade& f)
+    {
+      f.decrement();
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static bool equal(Facade1 const& f1, Facade2 const& f2)
+    {
+      return f1.equal(f2);
+    }
+
+    // XXX TODO: Investigate whether we need both of these cases
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+    //{
+    //  return f1.equal(f2);
+    //}
+
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+    //{
+    //  return f2.equal(f1);
+    //}
+
+    template <class Facade>
+    __host__ __device__
+    static void advance(Facade& f, typename Facade::difference_type n)
+    {
+      f.advance(n);
+    }
+
+    // Facade2 is convertible to Facade1,
+    // so return Facade1's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade1::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::true_type)
+    {
+      return -f1.distance_to(f2);
+    }
+
+    // Facade2 is not convertible to Facade1,
+    // so return Facade2's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade2::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::false_type)
+    {
+      return f2.distance_to(f1);
+    }
+    
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename thrust::detail::distance_from_result<Facade1,Facade2>::type
+      distance_from(Facade1 const& f1, Facade2 const& f2)
+    {
+      // dispatch the implementation of this method upon whether or not
+      // Facade2 is convertible to Facade1
+      return distance_from(f1, f2,
+        typename thrust::detail::is_convertible<Facade2,Facade1>::type());
+    }
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference>& facade)
+    {
+      return *static_cast<Derived*>(&facade);
+    }
+
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived const& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& facade)
+    {
+      return *static_cast<Derived const*>(&facade);
+    }
+
+    /*! \endcond
+     */
+}; // end iterator_core_access
+
+
+/*! \p iterator_facade is a template which allows the programmer to define a novel iterator with a standards-conforming interface
+ *  which Thrust can use to reason about algorithm acceleration opportunities.
+ *
+ *  Because most of a standard iterator's interface is defined in terms of a small set of core primitives, \p iterator_facade
+ *  defines the non-primitive portion mechanically. In principle a novel iterator could explicitly provide the entire interface in
+ *  an ad hoc fashion but doing so might be tedious and prone to subtle errors.
+ *
+ *  Often \p iterator_facade is too primitive a tool to use for defining novel iterators. In these cases, \p iterator_adaptor
+ *  or a specific fancy iterator should be used instead.
+ *
+ *  \p iterator_facade's functionality is derived from and generally equivalent to \p boost::iterator_facade.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems. An additional exception is Thrust's omission
+ *  of the \c operator-> member function.
+ *
+ *  Interested users may refer to <tt>boost::iterator_facade</tt>'s documentation for usage examples.
+ *
+ *  \note \p iterator_facade's arithmetic operator free functions exist with the usual meanings but are omitted here for brevity.
+ */
+template<typename Derived,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference = std::ptrdiff_t>
+  class iterator_facade
+{
+  private:
+    /*! \cond
+     */
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    __host__ __device__
+    Derived& derived()
+    {
+      return *static_cast<Derived*>(this);
+    }
+
+    __host__ __device__
+    Derived const& derived() const
+    {
+      return *static_cast<Derived const*>(this);
+    }
+    /*! \endcond
+     */
+
+  public:
+    /*! The type of element pointed to by \p iterator_facade.
+     */
+    typedef typename thrust::detail::remove_const<Value>::type value_type;
+
+    /*! The return type of \p iterator_facade::operator*().
+     */
+    typedef Reference                                          reference;
+
+    /*! The return type of \p iterator_facade's non-existent \c operator->()
+     *  member function. Unlike \c boost::iterator_facade, \p iterator_facade
+     *  disallows access to the \p value_type's members through expressions of the
+     *  form <tt>iter->member</tt>. \p pointer is defined to \c void to indicate
+     *  that these expressions are not allowed. This limitation may be relaxed in a
+     *  future version of Thrust.
+     */
+    typedef void                                               pointer;
+
+    /*! The type of expressions of the form <tt>x - y</tt> where <tt>x</tt> and <tt>y</tt>
+     *  are of type \p iterator_facade.
+     */
+    typedef Difference                                         difference_type;
+
+    /*! The type of iterator category of \p iterator_facade.
+     */
+    typedef typename thrust::detail::iterator_facade_category<
+      System, Traversal, Value, Reference
+    >::type                                                    iterator_category;
+
+    /*! \p operator*() dereferences this \p iterator_facade.
+     *  \return A reference to the element pointed to by this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator*() const
+    {
+      return iterator_core_access::dereference(this->derived());
+    }
+
+    // XXX unimplemented for now, consider implementing it later
+    //pointer operator->() const
+    //{
+    //  return;
+    //}
+
+    // XXX investigate whether or not we need to go to the lengths
+    //     boost does to determine the return type
+
+    /*! \p operator[] performs indexed dereference.
+     *  \return A reference to the element \p n distance away from this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator[](difference_type n) const
+    {
+      return *(this->derived() + n);
+    }
+
+    /*! \p operator++ pre-increments this \p iterator_facade to refer to the element in the next position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator++()
+    {
+      iterator_core_access::increment(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator++ post-increments this \p iterator_facade and returns a new \p iterator_facade referring to the element in the next position.
+     *  \return A copy of <tt>*this</tt> before increment.
+     */
+    __host__ __device__
+    Derived  operator++(int)
+    {
+      Derived tmp(this->derived());
+      ++*this;
+      return tmp;
+    }
+
+    /*! \p operator-- pre-decrements this \p iterator_facade to refer to the element in the previous position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator--()
+    {
+      iterator_core_access::decrement(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator-- post-decrements this \p iterator_facade and returns a new \p iterator_facade referring to the element in the previous position.
+     *  \return A copy of <tt>*this</tt> before decrement.
+     */
+    __host__ __device__
+    Derived  operator--(int)
+    {
+      Derived tmp(this->derived());
+      --*this;
+      return tmp;
+    }
+
+    /*! \p operator+= increments this \p iterator_facade to refer to an element a given distance after its current position.
+     *  \param n The quantity to increment.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator+=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), n);
+      return this->derived();
+    }
+
+    /*! \p operator-= decrements this \p iterator_facade to refer to an element a given distance before its current postition.
+     *  \param n The quantity to decrement.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator-=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), -n);
+      return this->derived();
+    }
+
+    /*! \p operator- subtracts a given quantity from this \p iterator_facade and returns a new \p iterator_facade referring to the element at the given position before this \p iterator_facade.
+     *  \param n The quantity to decrement
+     *  \return An \p iterator_facade pointing \p n elements before this \p iterator_facade.
+     */
+    __host__ __device__
+    Derived  operator-(difference_type n) const
+    {
+      Derived result(this->derived());
+      return result -= n;
+    }
+}; // end iterator_facade
+
+/*! \cond
+ */
+
+// Comparison operators
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return !iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 > iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 < iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 >= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 <= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator difference
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+
+// divine the type this operator returns
+typename thrust::detail::distance_from_result<
+  iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+  iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+>::type
+
+operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+          iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator addition
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i,
+                   typename Derived::difference_type n)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+/*! \endcond
+ */
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2f4b175a3fa4892640a42ae94dcfa9e2441f513
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/iterator_traits.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/iterator_traits.h
+ *  \brief Traits and metafunctions for reasoning about the traits of iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2003.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/type_traits/void_t.h>
+
+#include <iterator>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \p iterator_traits is a type trait class that provides a uniform
+ *  interface for querying the properties of iterators at compile-time.
+ */
+template <typename T>
+struct iterator_traits : std::iterator_traits<T> {};
+
+template<typename Iterator> struct iterator_value;
+
+template<typename Iterator> struct iterator_pointer;
+
+template<typename Iterator> struct iterator_reference;
+
+template<typename Iterator> struct iterator_difference;
+
+template<typename Iterator> struct iterator_traversal;
+
+template<typename Iterator> struct iterator_system;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/host_system_tag.h>
+#include <thrust/iterator/detail/device_system_tag.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/iterator/detail/iterator_traits.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/permutation_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/permutation_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..be5010e543bb08d33d3833a088b818c8ee415d92
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/permutation_iterator.h
@@ -0,0 +1,216 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/permutation_iterator.h
+ *  \brief An iterator which performs a gather or scatter operation when dereferenced
+ */
+
+/*
+ * (C) Copyright Toon Knapen    2001.
+ * (C) Copyright David Abrahams 2003.
+ * (C) Copyright Roland Richter 2003.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/permutation_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p permutation_iterator is an iterator which represents a pointer into a
+ *  reordered view of a given range. \p permutation_iterator is an imprecise name;
+ *  the reordered view need not be a strict permutation. This iterator is useful
+ *  for fusing a scatter or gather operation with other algorithms.
+ *
+ *  This iterator takes two arguments:
+ *
+ *    - an iterator to the range \c V on which the "permutation" will be applied
+ *    - the reindexing scheme that defines how the elements of \c V will be permuted.
+ *
+ *  Note that \p permutation_iterator is not limited to strict permutations of the
+ *  given range \c V. The distance between begin and end of the reindexing iterators
+ *  is allowed to be smaller compared to the size of the range \c V, in which case
+ *  the \p permutation_iterator only provides a "permutation" of a subrange of \c V.
+ *  The indices neither need to be unique. In this same context, it must be noted
+ *  that the past-the-end \p permutation_iterator is completely defined by means of
+ *  the past-the-end iterator to the indices.
+ *
+ *  The following code snippet demonstrates how to create a \p permutation_iterator
+ *  which represents a reordering of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/permutation_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> values(8);
+ *  values[0] = 10.0f;
+ *  values[1] = 20.0f;
+ *  values[2] = 30.0f;
+ *  values[3] = 40.0f;
+ *  values[4] = 50.0f;
+ *  values[5] = 60.0f;
+ *  values[6] = 70.0f;
+ *  values[7] = 80.0f;
+ *
+ *  thrust::device_vector<int> indices(4);
+ *  indices[0] = 2;
+ *  indices[1] = 6;
+ *  indices[2] = 1;
+ *  indices[3] = 3;
+ *
+ *  typedef thrust::device_vector<float>::iterator ElementIterator;
+ *  typedef thrust::device_vector<int>::iterator   IndexIterator;
+ *
+ *  thrust::permutation_iterator<ElementIterator,IndexIterator> iter(values.begin(), indices.begin());
+ *
+ *  *iter;   // returns 30.0f;
+ *  iter[0]; // returns 30.0f;
+ *  iter[1]; // returns 70.0f;
+ *  iter[2]; // returns 20.0f;
+ *  iter[3]; // returns 40.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  *iter   = -1.0f; // sets values[2] to -1.0f;
+ *  iter[0] = -1.0f; // sets values[2] to -1.0f;
+ *  iter[1] = -1.0f; // sets values[6] to -1.0f;
+ *  iter[2] = -1.0f; // sets values[1] to -1.0f;
+ *  iter[3] = -1.0f; // sets values[3] to -1.0f;
+ *
+ *  // values is now {10, -1, -1, -1, 50, 60, -1, 80}
+ *  \endcode
+ *
+ *  \see make_permutation_iterator
+ */
+template <typename ElementIterator,
+          typename IndexIterator>
+  class permutation_iterator
+    : public thrust::detail::permutation_iterator_base<
+        ElementIterator,
+        IndexIterator
+      >::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename detail::permutation_iterator_base<ElementIterator,IndexIterator>::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor calls the null constructor of this \p permutation_iterator's
+     *  element iterator.
+     */
+    __host__ __device__
+    permutation_iterator()
+      : m_element_iterator() {}
+
+    /*! Constructor accepts an \c ElementIterator into a range of values and an
+     *  \c IndexIterator into a range of indices defining the indexing scheme on the
+     *  values.
+     *
+     *  \param x An \c ElementIterator pointing this \p permutation_iterator's range of values.
+     *  \param y An \c IndexIterator pointing to an indexing scheme to use on \p x.
+     */
+    __host__ __device__
+    explicit permutation_iterator(ElementIterator x, IndexIterator y)
+      : super_t(y), m_element_iterator(x) {}
+
+    /*! Copy constructor accepts a related \p permutation_iterator.
+     *  \param r A compatible \p permutation_iterator to copy from.
+     */
+    template<typename OtherElementIterator, typename OtherIndexIterator>
+    __host__ __device__
+    permutation_iterator(permutation_iterator<OtherElementIterator,OtherIndexIterator> const &r
+    // XXX remove these guards when we have static_assert
+    , typename detail::enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
+    , typename detail::enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
+    )
+      : super_t(r.base()), m_element_iterator(r.m_element_iterator)
+    {}
+
+  /*! \cond
+   */
+  private:
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return *(m_element_iterator + *this->base());
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // make friends for the copy constructor
+    template<typename,typename> friend class permutation_iterator;
+
+    ElementIterator m_element_iterator;
+  /*! \endcond
+   */
+}; // end permutation_iterator
+
+
+/*! \p make_permutation_iterator creates a \p permutation_iterator
+ *  from an \c ElementIterator pointing to a range of elements to "permute"
+ *  and an \c IndexIterator pointing to a range of indices defining an indexing
+ *  scheme on the values.
+ *
+ *  \param e An \c ElementIterator pointing to a range of values.
+ *  \param i An \c IndexIterator pointing to an indexing scheme to use on \p e.
+ *  \return A new \p permutation_iterator which permutes the range \p e by \p i.
+ *  \see permutation_iterator
+ */
+template<typename ElementIterator, typename IndexIterator>
+__host__ __device__
+permutation_iterator<ElementIterator,IndexIterator> make_permutation_iterator(ElementIterator e, IndexIterator i)
+{
+  return permutation_iterator<ElementIterator,IndexIterator>(e,i);
+}
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/retag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/retag.h
new file mode 100644
index 0000000000000000000000000000000000000000..1eb770ae321344c08866fb571f3555c442dc6716
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/retag.h
@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/retag.h
+ *  \brief Functionality for altering an iterator's associated system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/retag.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+/*! \ingroup iterator_tags
+ *  \{
+ */
+
+#if 0
+/*! \p reinterpret_tag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag Any system tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is otherwise
+ *          equivalent to \p iter.
+ *  \note Unlike \p retag, \p reinterpret_tag does not enforce that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see retag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type reinterpret_tag(Iterator iter);
+
+/*! \p retag returns a copy of an iterator and changes the type of the result's system tag.
+ *  \tparam Tag \p Tag shall be convertible to <tt>thrust::iterator_system<Iterator>::type</tt>,
+ *              or <tt>thrust::iterator_system<Iterator>::type</tt> is a base type of \p Tag.
+ *  \tparam Iterator Any iterator type.
+ *  \param iter The iterator of interest.
+ *  \return An iterator of unspecified type whose system tag is \p Tag and whose behavior is
+ *          otherwise equivalent to \p iter.
+ *  \note Unlike \p reinterpret_tag, \p retag enforces that the converted-to system tag be
+ *        related to the converted-from system tag.
+ *  \see reinterpret_tag
+ */
+template<typename Tag, typename Iterator>
+__host__ __device__
+unspecified_iterator_type retag(Iterator iter);
+#endif
+
+/*! \} // iterator_tags
+ */
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/reverse_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/reverse_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe8bbe0cf832ca9eea9daced2de0dd20ca612639
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/reverse_iterator.h
@@ -0,0 +1,237 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/reverse_iterator.h
+ *  \brief An iterator adaptor which adapts another iterator to traverse backwards
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/reverse_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p reverse_iterator is an iterator which represents a pointer into a
+ *  reversed view of a given range. In this way, \p reverse_iterator allows
+ *  backwards iteration through a bidirectional input range.
+ *
+ *  It is important to note that although \p reverse_iterator is constructed
+ *  from a given iterator, it points to the element preceding it. In this way,
+ *  the past-the-end \p reverse_iterator of a given range points to the element
+ *  preceding the first element of the input range. By the same token, the first
+ *  \p reverse_iterator of a given range is constructed from a past-the-end iterator
+ *  of the original range yet points to the last element of the input.
+ *
+ *  The following code snippet demonstrates how to create a \p reverse_iterator
+ *  which represents a reversed view of the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/reverse_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  typedef thrust::device_vector<float>::iterator Iterator;
+ *
+ *  // note that we point the iterator to the *end* of the device_vector
+ *  thrust::reverse_iterator<Iterator> iter(values.end());
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Since reversing a range is a common operation, containers like \p device_vector
+ *  have nested typedefs for declaration shorthand and methods for constructing
+ *  reverse_iterators. The following code snippet is equivalent to the previous:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<float> v(4);
+ *  v[0] = 0.0f;
+ *  v[1] = 1.0f;
+ *  v[2] = 2.0f;
+ *  v[3] = 3.0f;
+ *
+ *  // we use the nested type reverse_iterator to refer to a reversed view of
+ *  // a device_vector and the method rbegin() to create a reverse_iterator pointing
+ *  // to the beginning of the reversed device_vector
+ *  thrust::device_iterator<float>::reverse_iterator iter = values.rbegin();
+ *
+ *  *iter;   // returns 3.0f;
+ *  iter[0]; // returns 3.0f;
+ *  iter[1]; // returns 2.0f;
+ *  iter[2]; // returns 1.0f;
+ *  iter[3]; // returns 0.0f;
+ *
+ *  // iter[4] is an out-of-bounds error
+ *
+ *  // similarly, rend() points to the end of the reversed sequence:
+ *  assert(values.rend() == (iter + 4));
+ *  \endcode
+ *
+ *  Finally, the following code snippet demonstrates how to use reverse_iterator to
+ *  perform a reversed prefix sum operation on the contents of a device_vector:
+ *
+ *  \code
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/scan.h>
+ *  ...
+ *  thrust::device_vector<int> v(5);
+ *  v[0] = 0;
+ *  v[1] = 1;
+ *  v[2] = 2;
+ *  v[3] = 3;
+ *  v[4] = 4;
+ *
+ *  thrust::device_vector<int> result(5);
+ *
+ *  // exclusive scan v into result in reverse
+ *  thrust::exclusive_scan(v.rbegin(), v.rend(), result.begin());
+ *
+ *  // result is now {0, 4, 7, 9, 10}
+ *  \endcode
+ *
+ *  \see make_reverse_iterator
+ */
+template<typename BidirectionalIterator>
+  class reverse_iterator
+    : public detail::reverse_iterator_base<BidirectionalIterator>::type
+{
+  /*! \cond
+   */
+  private:
+    typedef typename thrust::detail::reverse_iterator_base<
+      BidirectionalIterator
+    >::type super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Default constructor does nothing.
+     */
+    __host__ __device__
+    reverse_iterator() {}
+
+    /*! \p Constructor accepts a \c BidirectionalIterator pointing to a range
+     *  for this \p reverse_iterator to reverse.
+     *
+     *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+     */
+    __host__ __device__
+    explicit reverse_iterator(BidirectionalIterator x);
+
+    /*! \p Copy constructor allows construction from a related compatible
+     *  \p reverse_iterator.
+     *
+     *  \param r A \p reverse_iterator to copy from.
+     */
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    reverse_iterator(reverse_iterator<OtherBidirectionalIterator> const &r
+// XXX msvc screws this up
+// XXX remove these guards when we have static_assert
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     , typename thrust::detail::enable_if<
+                         thrust::detail::is_convertible<
+                           OtherBidirectionalIterator,
+                           BidirectionalIterator
+                         >::value
+                       >::type * = 0
+#endif // MSVC
+                     );
+
+  /*! \cond
+   */
+  private:
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    __host__ __device__
+    void increment();
+
+    __host__ __device__
+    void decrement();
+
+    __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    template<typename OtherBidirectionalIterator>
+    __host__ __device__
+    typename super_t::difference_type
+    distance_to(reverse_iterator<OtherBidirectionalIterator> const &y) const;
+  /*! \endcond
+   */
+}; // end reverse_iterator
+
+
+/*! \p make_reverse_iterator creates a \p reverse_iterator
+ *  from a \c BidirectionalIterator pointing to a range of elements to reverse.
+ *  
+ *  \param x A \c BidirectionalIterator pointing to a range to reverse.
+ *  \return A new \p reverse_iterator which reverses the range \p x.
+ */
+template<typename BidirectionalIterator>
+__host__ __device__
+reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/reverse_iterator.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_input_output_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_input_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5f725dc537122576ac016e5bed6da61d60b7ee8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_input_output_iterator.h
@@ -0,0 +1,164 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_input_output_iterator.h
+ *  \brief An iterator which adapts another iterator by applying transform
+ *         functions when reading and writing dereferenced values.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/transform_input_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_input_output_iterator is a special kind of iterator which applies
+ * transform functions when reading from or writing to dereferenced values.
+ * This iterator is useful for algorithms that operate on a type that needs to
+ * be serialized/deserialized from values in another iterator, avoiding the
+ * need to materialize intermediate results in memory. This also enables the
+ * transform functions to be fused with the operations that read and write to
+ * the `transform_input_output_iterator`.
+ *
+ * The following code snippet demonstrates how to create a
+ * \p transform_input_output_iterator which performs different transformations when
+ * reading from and writing to the iterator.
+ *
+ * \code
+ * #include <thrust/iterator/transform_input_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    const size_t size = 4;
+ *    thrust::device_vector<float> v(size);
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to vector
+ *    thrust::sequence(v.begin(), v.end(), 1);
+ *
+ *    // Iterator that returns negated values and writes squared values
+ *    auto iter = thrust::make_transform_input_output_iterator(v.begin(),
+ *        thrust::negate<float>{}, thrust::square<float>{});
+ * 
+ *    // Iterator negates values when reading
+ *    std::cout << iter[0] << " ";  // -1.0f;
+ *    std::cout << iter[1] << " ";  // -2.0f;
+ *    std::cout << iter[2] << " ";  // -3.0f;
+ *    std::cout << iter[3] << "\n"; // -4.0f;
+ *
+ *    // Write 1.0f, 2.0f, 3.0f, 4.0f to iterator
+ *    thrust::sequence(iter, iter + size, 1);
+ *
+ *    // Values were squared before writing to vector
+ *    std::cout << v[0] << " ";  // 1.0f;
+ *    std::cout << v[1] << " ";  // 4.0f;
+ *    std::cout << v[2] << " ";  // 9.0f;
+ *    std::cout << v[3] << "\n"; // 16.0f;
+ *
+ *  }
+ * \endcode
+ *
+ * \see make_transform_input_output_iterator
+ */
+
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+  class transform_input_output_iterator
+    : public detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_input_output_iterator_base<InputFunction, OutputFunction, Iterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_input_output_iterator() = default;
+
+  /*! This constructor takes as argument a \c Iterator an \c InputFunction and an
+   * \c OutputFunction and copies them to a new \p transform_input_output_iterator
+   *
+   * \param io An \c Iterator pointing to where the input to \c InputFunction
+   *           will be read from and the result of \c OutputFunction will be written to
+   * \param input_function An \c InputFunction to be executed on values read from the iterator
+   * \param output_function An \c OutputFunction to be executed on values written to the iterator
+   */
+    __host__ __device__
+    transform_input_output_iterator(Iterator const& io, InputFunction input_function, OutputFunction output_function)
+      : super_t(io), input_function(input_function), output_function(output_function)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_input_output_iterator_proxy<
+        InputFunction, OutputFunction, Iterator
+      >(this->base_reference(), input_function, output_function);
+    }
+
+    InputFunction input_function;
+    OutputFunction output_function;
+
+    /*! \endcond
+     */
+}; // end transform_input_output_iterator
+
+/*! \p make_transform_input_output_iterator creates a \p transform_input_output_iterator from
+ *  an \c Iterator a \c InputFunction and a \c OutputFunction
+ *
+ * \param io An \c Iterator pointing to where the input to \c InputFunction
+ *           will be read from and the result of \c OutputFunction will be written to
+ * \param input_function An \c InputFunction to be executed on values read from the iterator
+ * \param output_function An \c OutputFunction to be executed on values written to the iterator
+ *  \see transform_input_output_iterator
+ */
+template <typename InputFunction, typename OutputFunction, typename Iterator>
+transform_input_output_iterator<InputFunction, OutputFunction, Iterator>
+__host__ __device__
+make_transform_input_output_iterator(Iterator io, InputFunction input_function, OutputFunction output_function)
+{
+    return transform_input_output_iterator<InputFunction, OutputFunction, Iterator>(io, input_function, output_function);
+} // end make_transform_input_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..5afb5f37b0fa56999c25e19687c5ba4dab09329a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_iterator.h
@@ -0,0 +1,355 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/transform_iterator.h
+ *  \brief An iterator which adapts another iterator by applying a function to the result of its dereference
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #include the details first
+#include <thrust/iterator/detail/transform_iterator.inl>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_iterator is an iterator which represents a pointer into a range
+ *  of values after transformation by a function. This iterator is useful for
+ *  creating a range filled with the result of applying an operation to another range
+ *  without either explicitly storing it in memory, or explicitly executing the transformation.
+ *  Using \p transform_iterator facilitates kernel fusion by deferring the execution
+ *  of a transformation until the value is needed while saving both memory capacity
+ *  and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p transform_iterator
+ *  which represents the result of \c sqrtf applied to the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    thrust::transform_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p transform_iterator with the
+ *  \p thrust::reduce function to compute the sum of squares of a sequence.
+ *  We will create temporary \p transform_iterators with the
+ *  \p make_transform_iterator function in order to avoid explicitly specifying their type:
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/reduce.h>
+ *  #include <iostream>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return x * x;
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    // initialize a device array
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 2.0f;
+ *    v[2] = 3.0f;
+ *    v[3] = 4.0f;
+ *
+ *    float sum_of_squares =
+ *     thrust::reduce(thrust::make_transform_iterator(v.begin(), square()),
+ *                    thrust::make_transform_iterator(v.end(),   square()));
+ *
+ *    std::cout << "sum of squares: " << sum_of_squares << std::endl;
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Note that in the previous two examples the transform functor (namely \c square_root
+ *  and \c square) inherits from \c thrust::unary_function.  Inheriting from
+ *  \c thrust::unary_function ensures that a functor is a valid \c AdaptableUnaryFunction
+ *  and provides all the necessary \c typedef declarations.  The \p transform_iterator
+ *  can also be applied to a \c UnaryFunction that does not inherit from
+ *  \c thrust::unary_function using an optional template argument.  The following example
+ *  illustrates how to use the third template argument to specify the \c result_type of
+ *  the function.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor *does not* inherit from unary_function
+ *  struct square_root
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    // note: float result_type is specified explicitly
+ *    thrust::transform_iterator<square_root, FloatIterator, float> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
+  class transform_iterator
+    : public detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+{
+  /*! \cond
+   */
+  public:
+    typedef typename
+    detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor does nothing.
+     */
+    __host__ __device__
+    transform_iterator() {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    transform_iterator(transform_iterator const&) = default;
+#endif
+
+    /*! This constructor takes as arguments an \c Iterator and an \c AdaptableUnaryFunction
+     *  and copies them to a new \p transform_iterator.
+     *
+     *  \param x An \c Iterator pointing to the input to this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \param f An \c AdaptableUnaryFunction used to transform the objects pointed to by \p x.
+     */
+    __host__ __device__
+    transform_iterator(Iterator const& x, AdaptableUnaryFunction f)
+      : super_t(x), m_f(f) {
+    }
+
+    /*! This explicit constructor copies the value of a given \c Iterator and creates
+     *  this \p transform_iterator's \c AdaptableUnaryFunction using its null constructor.
+     *
+     *  \param x An \c Iterator to copy.
+     */
+    __host__ __device__
+    explicit transform_iterator(Iterator const& x)
+      : super_t(x) { }
+
+    /*! This copy constructor creates a new \p transform_iterator from another
+     *  \p transform_iterator.
+     *
+     *  \param other The \p transform_iterator to copy.
+     */
+    template<typename OtherAdaptableUnaryFunction,
+             typename OtherIterator,
+             typename OtherReference,
+             typename OtherValue>
+    __host__ __device__
+    transform_iterator(const transform_iterator<OtherAdaptableUnaryFunction, OtherIterator, OtherReference, OtherValue> &other,
+                       typename thrust::detail::enable_if_convertible<OtherIterator, Iterator>::type* = 0,
+                       typename thrust::detail::enable_if_convertible<OtherAdaptableUnaryFunction, AdaptableUnaryFunction>::type* = 0)
+      : super_t(other.base()), m_f(other.functor()) {}
+
+    /*! Copy assignment operator copies from another \p transform_iterator.
+     *  \p other The other \p transform_iterator to copy
+     *  \return <tt>*this</tt>
+     *
+     *  \note If the type of this \p transform_iterator's functor is not copy assignable
+     *        (for example, if it is a lambda) it is not an error to call this function.
+     *        In this case, however, the functor will not be modified.
+     *
+     *        In any case, this \p transform_iterator's underlying iterator will be copy assigned.
+     */
+    __host__ __device__
+    transform_iterator &operator=(const transform_iterator &other)
+    {
+      return do_assign(other,
+      // XXX gcc 4.2.1 crashes on is_copy_assignable; just assume the functor is assignable as a WAR
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION <= 40201)
+          thrust::detail::true_type()
+#else
+          typename thrust::detail::is_copy_assignable<AdaptableUnaryFunction>::type()
+#endif // THRUST_HOST_COMPILER
+      );
+    }
+
+    /*! This method returns a copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \return A copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     */
+    __host__ __device__
+    AdaptableUnaryFunction functor() const
+      { return m_f; }
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::true_type)
+    {
+      super_t::operator=(other);
+
+      // do assign to m_f
+      m_f = other.functor();
+
+      return *this;
+    }
+
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::false_type)
+    {
+      super_t::operator=(other);
+
+      // don't assign to m_f
+
+      return *this;
+    }
+
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      // Create a temporary to allow iterators with wrapped references to
+      // convert to their value type before calling m_f. Note that this
+      // disallows non-constant operations through m_f.
+      typename thrust::iterator_value<Iterator>::type const& x = *this->base();
+      return m_f(x);
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // tag this as mutable per Dave Abrahams in this thread:
+    // http://lists.boost.org/Archives/boost/2004/05/65332.php
+    mutable AdaptableUnaryFunction m_f;
+
+    /*! \endcond
+     */
+}; // end transform_iterator
+
+
+/*! \p make_transform_iterator creates a \p transform_iterator
+ *  from an \c Iterator and \c AdaptableUnaryFunction.
+ *
+ *  \param it The \c Iterator pointing to the input range of the
+ *            newly created \p transform_iterator.
+ *  \param fun The \c AdaptableUnaryFunction used to transform the range pointed
+ *             to by \p it in the newly created \p transform_iterator.
+ *  \return A new \p transform_iterator which transforms the range at
+ *          \p it by \p fun.
+ *  \see transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator>
+inline __host__ __device__
+transform_iterator<AdaptableUnaryFunction, Iterator>
+make_transform_iterator(Iterator it, AdaptableUnaryFunction fun)
+{
+  return transform_iterator<AdaptableUnaryFunction, Iterator>(it, fun);
+} // end make_transform_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_output_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_output_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ac4b85729e58151b94184974ef0f839663219f4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/transform_output_iterator.h
@@ -0,0 +1,164 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_output_iterator.h
+ *  \brief An output iterator which adapts another output iterator by applying a
+ *         function to the result of its dereference before writing it.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/transform_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_output_iterator is a special kind of output iterator which
+ * transforms a value written upon dereference. This iterator is useful
+ * for transforming an output from algorithms without explicitly storing the
+ * intermediate result in the memory and applying subsequent transformation, 
+ * thereby avoiding wasting memory capacity and bandwidth.
+ * Using \p transform_iterator facilitates kernel fusion by deferring execution
+ * of transformation until the value is written while saving both memory
+ * capacity and bandwidth.
+ *
+ * The following code snippet demonstrated how to create a
+ * \p transform_output_iterator which applies \c sqrtf to the assigning value.
+ *
+ * \code
+ * #include <thrust/iterator/transform_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ * // note: functor inherits form unary function
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *  
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *    thrust::transform_output_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    iter[0] =  1.0f;    // stores sqrtf( 1.0f) 
+ *    iter[1] =  4.0f;    // stores sqrtf( 4.0f)
+ *    iter[2] =  9.0f;    // stores sqrtf( 9.0f)
+ *    iter[3] = 16.0f;    // stores sqrtf(16.0f)
+ *    // iter[4] is an out-of-bounds error
+ *                                                                                           
+ *    v[0]; // returns 1.0f;
+ *    v[1]; // returns 2.0f;
+ *    v[2]; // returns 3.0f;
+ *    v[3]; // returns 4.0f;
+ *                                                                                           
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_output_iterator
+ */
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator
+    : public detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_output_iterator() = default;
+
+  /*! This constructor takes as argument an \c OutputIterator and an \c
+   * UnaryFunction and copies them to a new \p transform_output_iterator
+   *
+   * \param out An \c OutputIterator pointing to the output range whereto the result of 
+   *            \p transform_output_iterator's \c UnaryFunction will be written.
+   * \param fun An \c UnaryFunction used to transform the objects assigned to
+   *            this \p transform_output_iterator.
+   */
+    __host__ __device__
+    transform_output_iterator(OutputIterator const& out, UnaryFunction fun) : super_t(out), fun(fun)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_output_iterator_proxy<
+        UnaryFunction, OutputIterator
+      >(this->base_reference(), fun);
+    }
+
+    UnaryFunction fun;
+
+    /*! \endcond
+     */
+}; // end transform_output_iterator
+
+/*! \p make_transform_output_iterator creates a \p transform_output_iterator from
+ *  an \c OutputIterator and \c UnaryFunction.
+ *
+ *  \param out The \c OutputIterator pointing to the output range of the newly
+ *            created \p transform_output_iterator
+ *  \param fun The \c UnaryFunction transform the object before assigning it to
+ *            \c out by the newly created \p transform_output_iterator
+ *  \see transform_output_iterator
+ */
+template <typename UnaryFunction, typename OutputIterator>
+transform_output_iterator<UnaryFunction, OutputIterator>
+__host__ __device__
+make_transform_output_iterator(OutputIterator out, UnaryFunction fun)
+{
+    return transform_output_iterator<UnaryFunction, OutputIterator>(out, fun);
+} // end make_transform_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/zip_iterator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/zip_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2dd5ddc456f3b9945b88a0846cb112b9e6fde4d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/iterator/zip_iterator.h
@@ -0,0 +1,258 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/zip_iterator.h
+ *  \brief An iterator which returns a tuple of the result of dereferencing
+ *         a tuple of iterators when dereferenced
+ */
+
+/*
+ * Copyright David Abrahams and Thomas Becker 2000-2006.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/zip_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p zip_iterator is an iterator which represents a pointer into a range
+ *  of \p tuples whose elements are themselves taken from a \p tuple of input
+ *  iterators. This iterator is useful for creating a virtual array of structures
+ *  while achieving the same performance and bandwidth as the structure of arrays
+ *  idiom. \p zip_iterator also facilitates kernel fusion by providing a convenient
+ *  means of amortizing the execution of the same operation over multiple ranges.
+ *
+ *  The following code snippet demonstrates how to create a \p zip_iterator
+ *  which represents the result of "zipping" multiple ranges together.
+ *  
+ *  \code
+ *  #include <thrust/iterator/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> int_v(3);
+ *  int_v[0] = 0; int_v[1] = 1; int_v[2] = 2;
+ *
+ *  thrust::device_vector<float> float_v(3);
+ *  float_v[0] = 0.0f; float_v[1] = 1.0f; float_v[2] = 2.0f;
+ *
+ *  thrust::device_vector<char> char_v(3);
+ *  char_v[0] = 'a'; char_v[1] = 'b'; char_v[2] = 'c';
+ *
+ *  // typedef these iterators for shorthand
+ *  typedef thrust::device_vector<int>::iterator   IntIterator;
+ *  typedef thrust::device_vector<float>::iterator FloatIterator;
+ *  typedef thrust::device_vector<char>::iterator  CharIterator;
+ *
+ *  // typedef a tuple of these iterators
+ *  typedef thrust::tuple<IntIterator, FloatIterator, CharIterator> IteratorTuple;
+ *
+ *  // typedef the zip_iterator of this tuple
+ *  typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
+ *
+ *  // finally, create the zip_iterator
+ *  ZipIterator iter(thrust::make_tuple(int_v.begin(), float_v.begin(), char_v.begin()));
+ *
+ *  *iter;   // returns (0, 0.0f, 'a')
+ *  iter[0]; // returns (0, 0.0f, 'a')
+ *  iter[1]; // returns (1, 1.0f, 'b')
+ *  iter[2]; // returns (2, 2.0f, 'c')
+ *
+ *  thrust::get<0>(iter[2]); // returns 2
+ *  thrust::get<1>(iter[0]); // returns 0.0f
+ *  thrust::get<2>(iter[1]); // returns 'b'
+ *
+ *  // iter[3] is an out-of-bounds error
+ *  \endcode
+ *
+ *  Defining the type of a \p zip_iterator can be complex. The next code example demonstrates
+ *  how to use the \p make_zip_iterator function with the \p make_tuple function to avoid
+ *  explicitly specifying the type of the \p zip_iterator. This example shows how to use
+ *  \p zip_iterator to copy multiple ranges with a single call to \p thrust::copy.
+ *
+ *  \code
+ *  #include <thrust/zip_iterator.h>
+ *  #include <thrust/tuple.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> int_in(3), int_out(3);
+ *    int_in[0] = 0;
+ *    int_in[1] = 1;
+ *    int_in[2] = 2;
+ *
+ *    thrust::device_vector<float> float_in(3), float_out(3);
+ *    float_in[0] =  0.0f;
+ *    float_in[1] = 10.0f;
+ *    float_in[2] = 20.0f;
+ *
+ *    thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(int_in.begin(), float_in.begin())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_in.end(),   float_in.end())),
+ *                 thrust::make_zip_iterator(thrust::make_tuple(int_out.begin(),float_out.begin())));
+ *
+ *    // int_out is now [0, 1, 2]
+ *    // float_out is now [0.0f, 10.0f, 20.0f]
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_zip_iterator
+ *  \see make_tuple
+ *  \see tuple
+ *  \see get
+ */
+template <typename IteratorTuple>
+  class zip_iterator
+    : public detail::zip_iterator_base<IteratorTuple>::type
+{
+  public:
+    /*! Null constructor does nothing.
+     */
+    inline __host__ __device__
+    zip_iterator();
+
+    /*! This constructor creates a new \p zip_iterator from a
+     *  \p tuple of iterators.
+     *  
+     *  \param iterator_tuple The \p tuple of iterators to copy from.
+     */
+    inline __host__ __device__
+    zip_iterator(IteratorTuple iterator_tuple);
+
+    /*! This copy constructor creates a new \p zip_iterator from another
+     *  \p zip_iterator.
+     *
+     *  \param other The \p zip_iterator to copy.
+     */
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    zip_iterator(const zip_iterator<OtherIteratorTuple> &other,
+                 typename thrust::detail::enable_if_convertible<
+                   OtherIteratorTuple,
+                   IteratorTuple
+                 >::type * = 0);
+
+    /*! This method returns a \c const reference to this \p zip_iterator's
+     *  \p tuple of iterators.
+     *
+     *  \return A \c const reference to this \p zip_iterator's \p tuple
+     *          of iterators.
+     */
+    inline __host__ __device__
+    const IteratorTuple &get_iterator_tuple() const;
+
+    /*! \cond
+     */
+  private:
+    typedef typename
+    detail::zip_iterator_base<IteratorTuple>::type super_t;
+
+    friend class thrust::iterator_core_access;
+
+    // Dereferencing returns a tuple built from the dereferenced
+    // iterators in the iterator tuple.
+    __host__ __device__
+    typename super_t::reference dereference() const;
+
+    // Two zip_iterators are equal if the two first iterators of the
+    // tuple are equal. Note this differs from Boost's implementation, which
+    // considers the entire tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+    bool equal(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // Advancing a zip_iterator means to advance all iterators in the tuple
+    inline __host__ __device__
+    void advance(typename super_t::difference_type n);
+
+    // Incrementing a zip iterator means to increment all iterators in the tuple
+    inline __host__ __device__
+    void increment();
+
+    // Decrementing a zip iterator means to decrement all iterators in the tuple
+    inline __host__ __device__
+    void decrement();
+
+    // Distance is calculated using the first iterator in the tuple.
+    template<typename OtherIteratorTuple>
+    inline __host__ __device__
+      typename super_t::difference_type
+        distance_to(const zip_iterator<OtherIteratorTuple> &other) const;
+
+    // The iterator tuple.
+    IteratorTuple m_iterator_tuple;
+
+    /*! \endcond
+     */
+}; // end zip_iterator
+
+/*! \p make_zip_iterator creates a \p zip_iterator from a \p tuple
+ *  of iterators.
+ *
+ *  \param t The \p tuple of iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators encapsulated in \p t.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(thrust::tuple<Iterators...> t);
+
+
+/*! \p make_zip_iterator creates a \p zip_iterator from
+ *  iterators.
+ *
+ *  \param its The iterators to copy.
+ *  \return A newly created \p zip_iterator which zips the iterators.
+ *
+ *  \see zip_iterator
+ */
+template<typename... Iterators>
+inline __host__ __device__
+zip_iterator<thrust::tuple<Iterators...>> make_zip_iterator(Iterators... its);
+
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/iterator/detail/zip_iterator.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/limits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/limits.h
new file mode 100644
index 0000000000000000000000000000000000000000..52f38b1fc9e1aa2d92241338cf89d9dc4e5d1924
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/limits.h
@@ -0,0 +1,18 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <limits>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename T>
+struct numeric_limits : std::numeric_limits<T> {};
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/logical.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/logical.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a8dbbecf6e1b25bd9341d8ce3ba924fd488125d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/logical.h
@@ -0,0 +1,275 @@
+/*
+ *  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 logical.h
+ *  \brief Logical operations on ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup logical
+ *  \ingroup reductions
+ *  \{
+ */
+
+
+/*! \p all_of determines whether all elements in a range satify a predicate.
+ *  Specifically, \p all_of returns \c true if <tt>pred(*i)</tt> is \c true
+ *  for every iterator \c i in the range <tt>[first, last)</tt> and 
+ *  \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if all elements satisfy the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::all_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::all_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::all_of(thrust::host, A, A, thrust::identity<bool>()); // returns false
+ *  
+ *  \endcode
+ *
+ *  \see any_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool all_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \p all_of determines whether all elements in a range satify a predicate.
+ * Specifically, \p all_of returns \c true if <tt>pred(*i)</tt> is \c true
+ * for every iterator \c i in the range <tt>[first, last)</tt> and 
+ * \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if all elements satisfy the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::all_of(A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::all_of(A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::all_of(A, A, thrust::identity<bool>()); // returns false
+ *  
+ *  \endcode
+ *
+ *  \see any_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template<typename InputIterator, typename Predicate>
+bool all_of(InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \p any_of determines whether any element in a range satifies a predicate.
+ *  Specifically, \p any_of returns \c true if <tt>pred(*i)</tt> is \c true
+ *  for any iterator \c i in the range <tt>[first, last)</tt> and 
+ *  \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if any element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::any_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::any_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  thrust::any_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::any_of(thrust::host, A, A, thrust::identity<bool>()); // returns false
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool any_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred);
+   
+
+/*! \p any_of determines whether any element in a range satifies a predicate.
+ * Specifically, \p any_of returns \c true if <tt>pred(*i)</tt> is \c true
+ * for any iterator \c i in the range <tt>[first, last)</tt> and 
+ * \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if any element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::any_of(A, A + 2, thrust::identity<bool>()); // returns true
+ *  thrust::any_of(A, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  thrust::any_of(A + 2, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  // empty range
+ *  thrust::any_of(A, A, thrust::identity<bool>()); // returns false
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see none_of
+ *  \see transform_reduce
+ */
+template<typename InputIterator, typename Predicate>
+bool any_of(InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \p none_of determines whether no element in a range satifies a predicate.
+ *  Specifically, \p none_of returns \c true if there is no iterator \c i in 
+ *  the range <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true,
+ *  and \c false otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if no element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::none_of(thrust::host, A, A + 2, thrust::identity<bool>()); // returns false
+ *  thrust::none_of(thrust::host, A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  thrust::none_of(thrust::host, A + 2, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  // empty range
+ *  thrust::none_of(thrust::host, A, A, thrust::identity<bool>()); // returns true
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see any_of
+ *  \see transform_reduce
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool none_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \p none_of determines whether no element in a range satifies a predicate.
+ *  Specifically, \p none_of returns \c true if there is no iterator \c i in 
+ *  the range <tt>[first, last)</tt> such that <tt>pred(*i)</tt> is \c true,
+ *  and \c false otherwise.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param pred A predicate used to test range elements.
+ *  \return \c true, if no element satisfies the predicate; \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \code
+ *  #include <thrust/logical.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  bool A[3] = {true, true, false};
+ *
+ *  thrust::none_of(A, A + 2, thrust::identity<bool>()); // returns false
+ *  thrust::none_of(A, A + 3, thrust::identity<bool>()); // returns false
+ *
+ *  thrust::none_of(A + 2, A + 3, thrust::identity<bool>()); // returns true
+ *
+ *  // empty range
+ *  thrust::none_of(A, A, thrust::identity<bool>()); // returns true
+ *  \endcode
+ *
+ *  \see all_of
+ *  \see any_of
+ *  \see transform_reduce
+ */
+template<typename InputIterator, typename Predicate>
+bool none_of(InputIterator first, InputIterator last, Predicate pred);
+
+
+/*! \} // end logical
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/logical.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..819ac251301b1bdea886e5c0e3a82ecd850fab94
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/memory.h
@@ -0,0 +1,396 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/memory.h
+ *  \brief Abstractions for Thrust's memory model.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/reference.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/malloc_and_free.h>
+#include <thrust/detail/temporary_buffer.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \defgroup memory_management Memory Management
+ *
+ *  All Thrust functionalities related to memory allocation and deallocation.
+ *
+ */
+
+/** \addtogroup memory_management Memory Management
+ *  \{
+ */
+
+// define pointer for the purpose of Doxygenating it
+// it is actually defined elsewhere
+#if 0
+/*! \p pointer stores a pointer to an object allocated in memory. Like \p device_ptr, this
+ *  type ensures type safety when dispatching standard algorithms on ranges resident in memory.
+ *
+ *  \p pointer generalizes \p device_ptr by relaxing the backend system associated with the \p pointer.
+ *  Instead of the backend system specified by \p THRUST_DEVICE_SYSTEM, \p pointer's
+ *  system is given by its second template parameter, \p Tag. For the purpose of Thrust dispatch,
+ *  <tt>device_ptr<Element></tt> and <tt>pointer<Element,device_system_tag></tt> are considered equivalent.
+ *
+ *  The raw pointer encapsulated by a \p pointer may be obtained through its <tt>get</tt> member function
+ *  or the \p raw_pointer_cast free function.
+ *
+ *  \tparam Element specifies the type of the pointed-to object.
+ *
+ *  \tparam Tag specifies the system with which this \p pointer is associated. This may be any Thrust
+ *          backend system, or a user-defined tag.
+ *
+ *  \tparam Reference allows the client to specify the reference type returned upon derereference.
+ *          By default, this type is <tt>reference<Element,pointer></tt>.
+ *
+ *  \tparam Derived allows the client to specify the name of the derived type when \p pointer is used as
+ *          a base class. This is useful to ensure that arithmetic on values of the derived type return
+ *          values of the derived type as a result. By default, this type is <tt>pointer<Element,Tag,Reference></tt>.
+ *
+ *  \note \p pointer is not a smart pointer; it is the client's responsibility to deallocate memory
+ *        pointer to by \p pointer.
+ *
+ *  \see device_ptr
+ *  \see reference
+ *  \see raw_pointer_cast
+ */
+template<typename Element, typename Tag, typename Reference = thrust::use_default, typename Derived = thrust::use_default>
+  class pointer
+{
+  public:
+    /*! The type of the raw pointer
+     */
+    typedef typename super_t::base_type raw_pointer;
+
+    /*! \p pointer's default constructor initializes its encapsulated pointer to \c 0
+     */
+    __host__ __device__
+    pointer();
+
+    /*! This constructor allows construction of a <tt>pointer<const T, ...></tt> from a <tt>T*</tt>.
+     *
+     *  \param ptr A raw pointer to copy from, presumed to point to a location in \p Tag's memory.
+     *  \tparam OtherElement \p OtherElement shall be convertible to \p Element.
+     */
+    template<typename OtherElement>
+    __host__ __device__
+    explicit pointer(OtherElement *ptr);
+
+    /*! This contructor allows initialization from another pointer-like object.
+     *
+     *  \param other The \p OtherPointer to copy.
+     *
+     *  \tparam OtherPointer The tag associated with \p OtherPointer shall be convertible to \p Tag,
+     *                       and its element type shall be convertible to \p Element.
+     */
+    template<typename OtherPointer>
+    __host__ __device__
+    pointer(const OtherPointer &other,
+            typename thrust::detail::enable_if_pointer_is_convertible<
+              OtherPointer,
+              pointer<Element,Tag,Reference,Derived>
+            >::type * = 0);
+
+    /*! Assignment operator allows assigning from another pointer-like object whose element type
+     *  is convertible to \c Element.
+     *
+     *  \param other The other pointer-like object to assign from.
+     *  \return <tt>*this</tt>
+     *
+     *  \tparam OtherPointer The tag associated with \p OtherPointer shall be convertible to \p Tag,
+     *                       and its element type shall be convertible to \p Element.
+     */
+    template<typename OtherPointer>
+    __host__ __device__
+    typename thrust::detail::enable_if_pointer_is_convertible<
+      OtherPointer,
+      pointer,
+      derived_type &
+    >::type
+    operator=(const OtherPointer &other);
+
+    /*! \p get returns this \p pointer's encapsulated raw pointer.
+     *  \return This \p pointer's raw pointer.
+     */
+    __host__ __device__
+    Element *get() const;
+};
+#endif
+
+/*! This version of \p malloc allocates untyped uninitialized storage associated with a given system.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The number of bytes of storage to allocate.
+ *  \return If allocation succeeds, a pointer to the allocated storage; a null pointer otherwise.
+ *          The pointer must be deallocated with \p thrust::free.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publically derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p malloc to allocate a range of memory
+ *  associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate some memory with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<void,thrust::device_space_tag> void_ptr = thrust::malloc(device_sys, N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate void_ptr with thrust::free
+ *  thrust::free(device_sys, void_ptr);
+ *  \endcode
+ *
+ *  \see free
+ *  \see device_malloc
+ */
+template<typename DerivedPolicy>
+__host__ __device__
+pointer<void,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &system, std::size_t n);
+
+
+/*! This version of \p malloc allocates typed uninitialized storage associated with a given system.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The number of elements of type \c T which the storage should accomodate.
+ *  \return If allocation succeeds, a pointer to an allocation large enough to accomodate \c n
+ *          elements of type \c T; a null pointer otherwise.
+ *          The pointer must be deallocated with \p thrust::free.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publically derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p malloc to allocate a range of memory
+ *  to accomodate integers associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<int,thrust::device_system_tag> ptr = thrust::malloc<int>(device_sys, N);
+ *
+ *  // manipulate memory
+ *  ...
+ *
+ *  // deallocate ptr with thrust::free
+ *  thrust::free(device_sys, ptr);
+ *  \endcode
+ *
+ *  \see free
+ *  \see device_malloc
+ */
+template<typename T, typename DerivedPolicy>
+__host__ __device__
+pointer<T,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &system, std::size_t n);
+
+
+/*! \p get_temporary_buffer returns a pointer to storage associated with a given Thrust system sufficient to store up to
+ *  \p n objects of type \c T. If not enough storage is available to accomodate \p n objects, an implementation may return
+ *  a smaller buffer. The number of objects the returned buffer can accomodate is also returned.
+ *
+ *  Thrust uses \p get_temporary_buffer internally when allocating temporary storage required by algorithm implementations.
+ *
+ *  The storage allocated with \p get_temporary_buffer must be returned to the system with \p return_temporary_buffer.
+ *
+ *  \param system The Thrust system with which to associate the storage.
+ *  \param n The requested number of objects of type \c T the storage should accomodate.
+ *  \return A pair \c p such that <tt>p.first</tt> is a pointer to the allocated storage and <tt>p.second</tt> is the number of
+ *          contiguous objects of type \c T that the storage can accomodate. If no storage can be allocated, <tt>p.first</tt> if
+ *          no storage can be obtained. The storage must be returned to the system using \p return_temporary_buffer.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p DerivedPolicy must be publically derived from <tt>thrust::execution_policy<DerivedPolicy></tt>.
+ *
+ *  The following code snippet demonstrates how to use \p get_temporary_buffer to allocate a range of memory
+ *  to accomodate integers associated with Thrust's device system.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::get_temporary_buffer
+ *  const int N = 100;
+ *
+ *  typedef thrust::pair<
+ *    thrust::pointer<int,thrust::device_system_tag>,
+ *    std::ptrdiff_t
+ *  > ptr_and_size_t;
+ *
+ *  thrust::device_system_tag device_sys;
+ *  ptr_and_size_t ptr_and_size = thrust::get_temporary_buffer<int>(device_sys, N);
+ *
+ *  // manipulate up to 100 ints
+ *  for(int i = 0; i < ptr_and_size.second; ++i)
+ *  {
+ *    *ptr_and_size.first = i;
+ *  }
+ *
+ *  // deallocate storage with thrust::return_temporary_buffer
+ *  thrust::return_temporary_buffer(device_sys, ptr_and_size.first);
+ *  \endcode
+ *
+ *  \see malloc
+ *  \see return_temporary_buffer
+ */
+template<typename T, typename DerivedPolicy>
+__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> &system, typename thrust::pointer<T,DerivedPolicy>::difference_type n);
+
+/*! \p free deallocates the storage previously allocated by \p thrust::malloc.
+ *
+ *  \param system The Thrust system with which the storage is associated.
+ *  \param ptr A pointer previously returned by \p thrust::malloc. If \p ptr is null, \p free
+ *         does nothing.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p ptr shall have been returned by a previous call to <tt>thrust::malloc(system, n)</tt> or <tt>thrust::malloc<T>(system, n)</tt> for some type \c T.
+ *
+ *  The following code snippet demonstrates how to use \p free to deallocate a range of memory
+ *  previously allocated with \p thrust::malloc.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::malloc
+ *  const int N = 100;
+ *  thrust::device_system_tag device_sys;
+ *  thrust::pointer<int,thrust::device_system_tag> ptr = thrust::malloc<int>(device_sys, N);
+ *
+ *  // mainpulate memory
+ *  ...
+ *
+ *  // deallocate ptr with thrust::free
+ *  thrust::free(device_sys, ptr);
+ *  \endcode
+ */
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+void free(const thrust::detail::execution_policy_base<DerivedPolicy> &system, Pointer ptr);
+
+
+/*! \p return_temporary_buffer deallocates storage associated with a given Thrust system previously allocated by \p get_temporary_buffer.
+ *
+ *  Thrust uses \p return_temporary_buffer internally when deallocating temporary storage required by algorithm implementations.
+ *
+ *  \param system The Thrust system with which the storage is associated.
+ *  \param p A pointer previously returned by \p thrust::get_temporary_buffer. If \p ptr is null, \p return_temporary_buffer does nothing.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *
+ *  \pre \p p shall have been previously allocated by \p thrust::get_temporary_buffer.
+ *
+ *  The following code snippet demonstrates how to use \p return_temporary_buffer to deallocate a range of memory
+ *  previously allocated by \p get_temporary_buffer.
+ *
+ *  \code
+ *  #include <thrust/memory.h>
+ *  ...
+ *  // allocate storage for 100 ints with thrust::get_temporary_buffer
+ *  const int N = 100;
+ *
+ *  typedef thrust::pair<
+ *    thrust::pointer<int,thrust::device_system_tag>,
+ *    std::ptrdiff_t
+ *  > ptr_and_size_t;
+ *
+ *  thrust::device_system_tag device_sys;
+ *  ptr_and_size_t ptr_and_size = thrust::get_temporary_buffer<int>(device_sys, N);
+ *
+ *  // manipulate up to 100 ints
+ *  for(int i = 0; i < ptr_and_size.second; ++i)
+ *  {
+ *    *ptr_and_size.first = i;
+ *  }
+ *
+ *  // deallocate storage with thrust::return_temporary_buffer
+ *  thrust::return_temporary_buffer(device_sys, ptr_and_size.first);
+ *  \endcode
+ *
+ *  \see free
+ *  \see get_temporary_buffer
+ */
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+void return_temporary_buffer(const thrust::detail::execution_policy_base<DerivedPolicy> &system, Pointer p, std::ptrdiff_t n);
+
+
+/*! \p raw_pointer_cast creates a "raw" pointer from a pointer-like type,
+ *  simply returning the wrapped pointer, should it exist.
+ *
+ *  \param ptr The pointer of interest.
+ *  \return <tt>ptr.get()</tt>, if the expression is well formed; <tt>ptr</tt>, otherwise.
+ *  \see raw_reference_cast
+ */
+template<typename Pointer>
+__host__ __device__
+typename thrust::detail::pointer_traits<Pointer>::raw_pointer
+  raw_pointer_cast(Pointer ptr);
+
+
+/*! \p raw_reference_cast creates a "raw" reference from a wrapped reference type,
+ *  simply returning the underlying reference, should it exist.
+ *
+ *  If the argument is not a reference wrapper, the result is a reference to the argument.
+ *
+ *  \param ref The reference of interest.
+ *  \return <tt>*thrust::raw_pointer_cast(&ref)</tt>.
+ *  \note There are two versions of \p raw_reference_cast. One for <tt>const</tt> references,
+ *        and one for non-<tt>const</tt>.
+ *  \see raw_pointer_cast
+ */
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<T>::type
+  raw_reference_cast(T &ref);
+
+
+/*! \p raw_reference_cast creates a "raw" reference from a wrapped reference type,
+ *  simply returning the underlying reference, should it exist.
+ *
+ *  If the argument is not a reference wrapper, the result is a reference to the argument.
+ *
+ *  \param ref The reference of interest.
+ *  \return <tt>*thrust::raw_pointer_cast(&ref)</tt>.
+ *  \note There are two versions of \p raw_reference_cast. One for <tt>const</tt> references,
+ *        and one for non-<tt>const</tt>.
+ *  \see raw_pointer_cast
+ */
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<const T>::type
+  raw_reference_cast(const T &ref);
+
+/*! \} // memory_management
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/merge.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/merge.h
new file mode 100644
index 0000000000000000000000000000000000000000..724f4c167f16b7306328e85236e971966e52b247
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/merge.h
@@ -0,0 +1,677 @@
+/*
+ *  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 merge.h
+ *  \brief Merging sorted ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup merging Merging
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sorted sets of integers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[13];
+ *
+ *  int *result_end =
+ *    thrust::merge(thrust::host,
+ *                  A1, A1 + 6,
+ *                  A2, A2 + 7,
+ *                  result);
+ *  // result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p set_union
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result);
+
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sorted sets of integers.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(A1, A1 + 6, A2, A2 + 7, result);
+ *  // result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p set_union
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result);
+
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sets of integers sorted in
+ *  descending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(thrust::host,
+ *                                  A1, A1 + 6,
+ *                                  A2, A2 + 7,
+ *                                  result,
+ *                                  thrust::greater<int>());
+ *  // result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakCompare comp);
+
+
+/*! \p merge combines two sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>
+ *  into a single sorted range. That is, it copies from <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt> into <tt>[result, result + (last1 - first1) + (last2 - first2))</tt>
+ *  such that the resulting range is in ascending order. \p merge is stable, meaning both that the
+ *  relative order of elements within each input range is preserved, and that for equivalent elements
+ *  in both input ranges the element from the first range precedes the element from the second. The
+ *  return value is <tt>result + (last1 - first1) + (last2 - first2)</tt>.
+ *
+ *  This version of \p merge compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the merged output.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge to compute the merger of two sets of integers sorted in
+ *  descending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int result[13];
+ *
+ *  int *result_end = thrust::merge(A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
+ *  // result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/merge
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakCompare comp);
+
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 - keys_first1))</tt>
+ *  and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range,
+ *  <tt>[values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  ascending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
+ *  int B_vals[7] = {1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end =
+ *    thrust::merge_by_key(thrust::host,
+ *                         A_keys, A_keys + 6,
+ *                         B_keys, B_keys + 7,
+ *                         A_vals, B_vals,
+ *                         keys_result, vals_result);
+ *
+ *  // keys_result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  // vals_result = {0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,  0,  1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result);
+
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 - keys_first1))</tt>
+ *  and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range,
+ *  <tt>[values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  ascending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {1, 1, 2, 3, 5, 8, 13};
+ *  int B_vals[7] = {1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals, keys_result, vals_result);
+ *
+ *  // keys_result = {1, 1, 1, 2, 3, 3, 5, 5, 7, 8, 9, 11, 13}
+ *  // vals_result = {0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,  0,  1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result);
+
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 - keys_first1))</tt>
+ *  and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range,
+ *  <tt>[values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  This version of \p merge_by_key compares key elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized using \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator1's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator1's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  descending order using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *  int B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end =
+ *    thrust::merge_by_key(thrust::host,
+ *                         A_keys, A_keys + 6,
+ *                         B_keys, B_keys + 7,
+ *                         A_vals, B_vals,
+ *                         keys_result, vals_result,
+ *                         thrust::greater<int>());
+ *
+ *  // keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  // vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename Compare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 Compare comp);
+
+
+/*! \p merge_by_key performs a key-value merge. That is, \p merge_by_key copies elements from
+ *  <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> into a single range,
+ *  <tt>[keys_result, keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending key order.
+ *
+ *  At the same time, \p merge_by_key copies elements from the two associated ranges <tt>[values_first1 + (keys_last1 - keys_first1))</tt>
+ *  and <tt>[values_first2 + (keys_last2 - keys_first2))</tt> into a single range,
+ *  <tt>[values_result, values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt> such that
+ *  the resulting range is in ascending order implied by each input element's associated key.
+ *
+ *  \p merge_by_key is stable, meaning both that the relative order of elements within each input range is
+ *  preserved, and that for equivalent elements in all input key ranges the element from the first range
+ *  precedes the element from the second.
+ *
+ *  The return value is is <tt>(keys_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>
+ *  and <tt>(values_result + (keys_last1 - keys_first1) + (keys_last2 - keys_first2))</tt>.
+ *
+ *  This version of \p merge_by_key compares key elements using a function object \p comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the merged output range of keys.
+ *  \param values_result The beginning of the merged output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator1's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator1's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use
+ *  \p merge_by_key to compute the merger of two sets of integers sorted in
+ *  descending order.
+ *
+ *  \code
+ *  #include <thrust/merge.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *  int B_vals[7] = { 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int keys_result[13];
+ *  int vals_result[13];
+ *
+ *  thrust::pair<int*,int*> end = thrust::merge_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
+ *
+ *  // keys_result = {13, 11, 9, 8, 7, 5, 5, 3, 3, 2, 1, 1, 1}
+ *  // vals_result = { 1,  0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1}
+ *  \endcode
+ *
+ *  \see merge
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename StrictWeakCompare>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 StrictWeakCompare comp);
+
+
+/*! \} // merging
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/merge.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mismatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mismatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbdf2923a09e87b143920454d4473204bd3a0388
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mismatch.h
@@ -0,0 +1,257 @@
+/*
+ *  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 mismatch.h
+ *  \brief Search for differences between ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup searching
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p mismatch finds the first position where the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> differ. The two versions of 
+ *  \p mismatch use different tests for whether elements differ.
+ *
+ *  This version of \p mismatch finds the first iterator \c i in <tt>[first1, last1)</tt>
+ *  such that <tt>*i == *(first2 + (i - first1))</tt> is \c false. The return value is a
+ *  \c pair whose first element is \c i and whose second element is <tt>*(first2 + (i - first1))</tt>.
+ *  If no such iterator \c i exists, the return value is a \c pair whose first element
+ *  is \c last1 and whose second element is <tt>*(first2 + (last1 - first1))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return The first position where the sequences differ.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \p InputIterator1's \c value_type is equality comparable to \p InputIterator2's \c value_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *
+ *  \code
+ *  #include <thrust/mismatch.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> vec1(4);
+ *  thrust::device_vector<int> vec2(4);
+ *
+ *  vec1[0] = 0;  vec2[0] = 0; 
+ *  vec1[1] = 5;  vec2[1] = 5;
+ *  vec1[2] = 3;  vec2[2] = 8;
+ *  vec1[3] = 7;  vec2[3] = 7;
+ *
+ *  typedef thrust::device_vector<int>::iterator Iterator;
+ *  thrust::pair<Iterator,Iterator> result;
+ *
+ *  result = thrust::mismatch(thrust::device, vec1.begin(), vec1.end(), vec2.begin());
+ *
+ *  // result.first  is vec1.begin() + 2
+ *  // result.second is vec2.begin() + 2
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+thrust::pair<InputIterator1, InputIterator2> mismatch(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                                      InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2);
+
+
+/*! \p mismatch finds the first position where the two ranges <tt>[first1, last1)</tt>
+ * and <tt>[first2, first2 + (last1 - first1))</tt> differ. The two versions of 
+ * \p mismatch use different tests for whether elements differ.
+ *
+ * This version of \p mismatch finds the first iterator \c i in <tt>[first1, last1)</tt>
+ * such that <tt>*i == *(first2 + (i - first1))</tt> is \c false. The return value is a
+ * \c pair whose first element is \c i and whose second element is <tt>*(first2 + (i - first1))</tt>.
+ * If no such iterator \c i exists, the return value is a \c pair whose first element
+ * is \c last1 and whose second element is <tt>*(first2 + (last1 - first1))</tt>.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \return The first position where the sequences differ.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \p InputIterator1's \c value_type is equality comparable to \p InputIterator2's \c value_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *
+ *  \code
+ *  #include <thrust/mismatch.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec1(4);
+ *  thrust::device_vector<int> vec2(4);
+ *
+ *  vec1[0] = 0;  vec2[0] = 0; 
+ *  vec1[1] = 5;  vec2[1] = 5;
+ *  vec1[2] = 3;  vec2[2] = 8;
+ *  vec1[3] = 7;  vec2[3] = 7;
+ *
+ *  typedef thrust::device_vector<int>::iterator Iterator;
+ *  thrust::pair<Iterator,Iterator> result;
+ *
+ *  result = thrust::mismatch(vec1.begin(), vec1.end(), vec2.begin());
+ *
+ *  // result.first  is vec1.begin() + 2
+ *  // result.second is vec2.begin() + 2
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ */
+template <typename InputIterator1, typename InputIterator2>
+thrust::pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2);
+
+
+/*! \p mismatch finds the first position where the two ranges <tt>[first1, last1)</tt>
+ *  and <tt>[first2, first2 + (last1 - first1))</tt> differ. The two versions of 
+ *  \p mismatch use different tests for whether elements differ.
+ *
+ *  This version of \p mismatch finds the first iterator \c i in <tt>[first1, last1)</tt>
+ *  such that <tt>pred(\*i, \*(first2 + (i - first1))</tt> is \c false. The return value is a
+ *  \c pair whose first element is \c i and whose second element is <tt>*(first2 + (i - first1))</tt>.
+ *  If no such iterator \c i exists, the return value is a \c pair whose first element is
+ *  \c last1 and whose second element is <tt>*(first2 + (last1 - first1))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param pred   The binary predicate to compare elements.
+ *  \return The first position where the sequences differ.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Input Iterator</a>.
+ *
+ *  \code
+ *  #include <thrust/mismatch.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> vec1(4);
+ *  thrust::device_vector<int> vec2(4);
+ *
+ *  vec1[0] = 0;  vec2[0] = 0; 
+ *  vec1[1] = 5;  vec2[1] = 5;
+ *  vec1[2] = 3;  vec2[2] = 8;
+ *  vec1[3] = 7;  vec2[3] = 7;
+ *
+ *  typedef thrust::device_vector<int>::iterator Iterator;
+ *  thrust::pair<Iterator,Iterator> result;
+ *
+ *  result = thrust::mismatch(thrust::device, vec1.begin(), vec1.end(), vec2.begin(), thrust::equal_to<int>());
+ *
+ *  // result.first  is vec1.begin() + 2
+ *  // result.second is vec2.begin() + 2
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<InputIterator1, InputIterator2> mismatch(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                                      InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2,
+                                                      BinaryPredicate pred);
+
+
+/*! \p mismatch finds the first position where the two ranges <tt>[first1, last1)</tt>
+ * and <tt>[first2, first2 + (last1 - first1))</tt> differ. The two versions of 
+ * \p mismatch use different tests for whether elements differ.
+ *
+ * This version of \p mismatch finds the first iterator \c i in <tt>[first1, last1)</tt>
+ * such that <tt>pred(\*i, \*(first2 + (i - first1))</tt> is \c false. The return value is a
+ * \c pair whose first element is \c i and whose second element is <tt>*(first2 + (i - first1))</tt>.
+ * If no such iterator \c i exists, the return value is a \c pair whose first element is
+ * \c last1 and whose second element is <tt>*(first2 + (last1 - first1))</tt>.
+ *
+ *  \param first1 The beginning of the first sequence.
+ *  \param last1  The end of the first sequence.
+ *  \param first2 The beginning of the second sequence.
+ *  \param pred   The binary predicate to compare elements.
+ *  \return The first position where the sequences differ.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Input Iterator</a>.
+ *
+ *  \code
+ *  #include <thrust/mismatch.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec1(4);
+ *  thrust::device_vector<int> vec2(4);
+ *
+ *  vec1[0] = 0;  vec2[0] = 0; 
+ *  vec1[1] = 5;  vec2[1] = 5;
+ *  vec1[2] = 3;  vec2[2] = 8;
+ *  vec1[3] = 7;  vec2[3] = 7;
+ *
+ *  typedef thrust::device_vector<int>::iterator Iterator;
+ *  thrust::pair<Iterator,Iterator> result;
+ *
+ *  result = thrust::mismatch(vec1.begin(), vec1.end(), vec2.begin(), thrust::equal_to<int>());
+ *
+ *  // result.first  is vec1.begin() + 2
+ *  // result.second is vec2.begin() + 2
+ *  \endcode
+ *
+ *  \see find
+ *  \see find_if
+ */
+template <typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+thrust::pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+                                                      InputIterator1 last1,
+                                                      InputIterator2 first2,
+                                                      BinaryPredicate pred);
+
+/*! \} // end searching
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/mismatch.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..67adbe87c3472ead70b95f87277fd285443324c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/allocator.h
@@ -0,0 +1,253 @@
+/*
+ *  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 <limits>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/config/exec_check_disable.h>
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/validator.h>
+#include <thrust/mr/polymorphic_adaptor.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup allocators Allocators
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! An \p mr::allocator is a template that fulfills the C++ requirements for Allocators,
+ *  allowing to use the NPA-based memory resources where an Allocator is required. Unlike
+ *  memory resources, but like other allocators, \p mr::allocator is typed and bound to
+ *  allocate object of a specific type, however it can be freely rebound to other types.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam MR the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, class MR>
+class allocator : private validator<MR>
+{
+public:
+    /*! The pointer to void type of this allocator. */
+    typedef typename MR::pointer void_pointer;
+
+    /*! The value type allocated by this allocator. Equivalent to \p T. */
+    typedef T value_type;
+    /*! The pointer type allocated by this allocator. Equivaled to the pointer type of \p MR rebound to \p T. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<T>::other pointer;
+    /*! The pointer to const type. Equivalent to a pointer type of \p MR rebound to <tt>const T</tt>. */
+    typedef typename thrust::detail::pointer_traits<void_pointer>::template rebind<const T>::other const_pointer;
+    /*! The reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<pointer>::reference reference;
+    /*! The const reference to the type allocated by this allocator. Supports smart references. */
+    typedef typename thrust::detail::pointer_traits<const_pointer>::reference const_reference;
+    /*! The size type of this allocator. Always \p std::size_t. */
+    typedef std::size_t size_type;
+    /*! The difference type between pointers allocated by this allocator. */
+    typedef typename thrust::detail::pointer_traits<pointer>::difference_type difference_type;
+
+    /*! Specifies that the allocator shall be propagated on container copy assignment. */
+    typedef detail::true_type propagate_on_container_copy_assignment;
+    /*! Specifies that the allocator shall be propagated on container move assignment. */
+    typedef detail::true_type propagate_on_container_move_assignment;
+    /*! Specifies that the allocator shall be propagated on container swap. */
+    typedef detail::true_type propagate_on_container_swap;
+
+    /*! The \p rebind metafunction provides the type of an \p allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p allocator.
+         */
+        typedef allocator<U, MR> other;
+    };
+
+    /*! Calculates the maximum number of elements allocated by this allocator.
+     *
+     *  \return the maximum value of \p std::size_t, divided by the size of \p T.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)() / sizeof(T);
+    }
+
+    /*! Constructor.
+     *
+     *  \param resource the resource to be used to allocate raw memory.
+     */
+    __host__ __device__
+    allocator(MR * resource) : mem_res(resource)
+    {
+    }
+
+    /*! Copy constructor. Copies the resource pointer. */
+    template<typename U>
+    __host__ __device__
+    allocator(const allocator<U, MR> & other) : mem_res(other.resource())
+    {
+    }
+
+    /*! Allocates objects of type \p T.
+     *
+     *  \param n number of elements to allocate
+     *  \return a pointer to the newly allocated storage.
+     */
+    THRUST_NODISCARD
+    __host__
+    pointer allocate(size_type n)
+    {
+        return static_cast<pointer>(mem_res->do_allocate(n * sizeof(T), THRUST_ALIGNOF(T)));
+    }
+
+    /*! Deallocates objects of type \p T.
+     *
+     *  \param p pointer returned by a previous call to \p allocate
+     *  \param n number of elements, passed as an argument to the \p allocate call that produced \p p
+     */
+    __host__
+    void deallocate(pointer p, size_type n)
+    {
+        return mem_res->do_deallocate(p, n * sizeof(T), THRUST_ALIGNOF(T));
+    }
+
+    /*! Extracts the memory resource used by this allocator.
+     *
+     *  \return the memory resource used by this allocator.
+     */
+    __host__ __device__
+    MR * resource() const
+    {
+        return mem_res;
+    }
+
+private:
+    MR * mem_res;
+};
+
+/*! Compares the allocators for equality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator==(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return *lhs.resource() == *rhs.resource();
+}
+
+/*! Compares the allocators for inequality by comparing the underlying memory resources. */
+template<typename T, typename MR>
+__host__ __device__
+bool operator!=(const allocator<T, MR> & lhs, const allocator<T, MR> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template<typename T, typename Pointer>
+using polymorphic_allocator = allocator<T, polymorphic_adaptor_resource<Pointer> >;
+
+#else // C++11
+
+template<typename T, typename Pointer>
+class polymorphic_allocator : public allocator<T, polymorphic_adaptor_resource<Pointer> >
+{
+    typedef allocator<T, polymorphic_adaptor_resource<Pointer> > base;
+
+public:
+    /*! Initializes the base class with the parameter \p resource.
+     */
+    polymorphic_allocator(polymorphic_adaptor_resource<Pointer>  * resource) : base(resource)
+    {
+    }
+};
+
+#endif // C++11
+
+/*! A helper allocator class that uses global instances of a given upstream memory resource. Requires the memory resource
+ *      to be default constructible.
+ *
+ *  \tparam T the type that will be allocated by this allocator.
+ *  \tparam Upstream the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final (in C++11 and beyond).
+ */
+template<typename T, typename Upstream>
+class stateless_resource_allocator : public thrust::mr::allocator<T, Upstream>
+{
+    typedef thrust::mr::allocator<T, Upstream> base;
+
+public:
+    /*! The \p rebind metafunction provides the type of an \p stateless_resource_allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p stateless_resource_allocator.
+         */
+        typedef stateless_resource_allocator<U, Upstream> other;
+    };
+
+    /*! Default constructor. Uses \p get_global_resource to get the global instance of \p Upstream and initializes the
+     *      \p allocator base subobject with that resource.
+     */
+    __thrust_exec_check_disable__
+    __host__ __device__
+    stateless_resource_allocator() : base(get_global_resource<Upstream>())
+    {
+    }
+
+    /*! Copy constructor. Copies the memory resource pointer. */
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator & other)
+        : base(other) {}
+
+    /*! Conversion constructor from an allocator of a different type. Copies the memory resource pointer. */
+    template<typename U>
+    __host__ __device__
+    stateless_resource_allocator(const stateless_resource_allocator<U, Upstream> & other)
+        : base(other) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    stateless_resource_allocator & operator=(const stateless_resource_allocator &) = default;
+#endif
+
+    /*! Destructor. */
+    __host__ __device__
+    ~stateless_resource_allocator() {}
+};
+
+/*! \} // allocators
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/device_memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/device_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a671142aaf921e1191eb234f0ae96f29b204423
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/device_memory_resource.h
@@ -0,0 +1,38 @@
+/*
+ *  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>
+
+// #include the device system's memory_resource header
+#define __THRUST_DEVICE_SYSTEM_MEMORY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::memory_resource
+    device_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_memory_resource
+    universal_memory_resource;
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_host_pinned_memory_resource
+    universal_host_pinned_memory_resource;
+
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..b00a8644ccadb68ae821072178844ec98ffed0fc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_pool.h
@@ -0,0 +1,489 @@
+/*
+ *  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/algorithm_wrapper.h>
+#include <thrust/detail/config.h>
+
+#include <thrust/host_vector.h>
+#include <thrust/binary_search.h>
+#include <thrust/detail/seq.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/pool_options.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource adaptor allowing for pooling and caching allocations from \p Upstream, using \p Bookkeeper for
+ *      management of that cached and pooled memory, allowing to cache portions of memory inaccessible from the host.
+ *
+ *  On a typical memory resource, calls to \p allocate and \p deallocate actually allocate and deallocate memory. Pooling
+ *      memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when
+ *      there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make
+ *      memory allocation faster and more efficient.
+ *
+ *  The disjoint version of the pool resources uses a separate upstream memory resource, \p Bookkeeper, to allocate memory
+ *      necessary to manage the cached memory. There may be many reasons to do that; the canonical one is that \p Upstream
+ *      allocates memory that is inaccessible to the code of the pool resource, which means that it cannot embed the necessary
+ *      information in memory obtained from \p Upstream; for instance, \p Upstream can be a CUDA non-managed memory
+ *      resource, or a CUDA managed memory resource whose memory we would prefer to not migrate back and forth between
+ *      host and device when executing bookkeeping code.
+ *
+ *  This is not the only case where it makes sense to use a disjoint pool resource, though. In a multi-core environment
+ *      it may be beneficial to avoid stealing cache lines from other cores by writing over bookkeeping information
+ *      embedded in an allocated block of memory. In such a case, one can imagine wanting to use a disjoint pool where
+ *      both the upstream and the bookkeeper are of the same type, to allocate memory consistently, but separately for
+ *      those two purposes.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+class disjoint_unsynchronized_pool_resource final
+    : public memory_resource<typename Upstream::pointer>,
+        private validator2<Upstream, Bookkeeper>
+{
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        pool_options ret;
+
+        ret.min_blocks_per_chunk = 16;
+        ret.min_bytes_per_chunk = 1024;
+        ret.max_blocks_per_chunk = static_cast<std::size_t>(1) << 20;
+        ret.max_bytes_per_chunk = static_cast<std::size_t>(1) << 30;
+
+        ret.smallest_block_size = THRUST_MR_DEFAULT_ALIGNMENT;
+        ret.largest_block_size = static_cast<std::size_t>(1) << 20;
+
+        ret.alignment = THRUST_MR_DEFAULT_ALIGNMENT;
+
+        ret.cache_oversized = true;
+
+        ret.cached_size_cutoff_factor = 16;
+        ret.cached_alignment_cutoff_factor = 16;
+
+        return ret;
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : m_upstream(upstream),
+        m_bookkeeper(bookkeeper),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    // TODO: C++11: use delegating constructors
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_unsynchronized_pool_resource(pool_options options = get_default_options())
+        : m_upstream(get_global_resource<Upstream>()),
+        m_bookkeeper(get_global_resource<Bookkeeper>()),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(m_bookkeeper),
+        m_allocated(m_bookkeeper),
+        m_cached_oversized(m_bookkeeper),
+        m_oversized(m_bookkeeper)
+    {
+        assert(m_options.validate());
+
+        pointer_vector free(m_bookkeeper);
+        pool p(free);
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    /*! Destructor. Releases all held memory to upstream.
+     */
+    ~disjoint_unsynchronized_pool_resource()
+    {
+        release();
+    }
+
+private:
+    typedef typename Upstream::pointer void_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<char>::other char_ptr;
+
+    struct chunk_descriptor
+    {
+        std::size_t size;
+        void_ptr pointer;
+    };
+
+    typedef thrust::host_vector<
+        chunk_descriptor,
+        allocator<chunk_descriptor, Bookkeeper>
+    > chunk_vector;
+
+    struct oversized_block_descriptor
+    {
+        std::size_t size;
+        std::size_t alignment;
+        void_ptr pointer;
+
+        __host__ __device__
+        bool operator==(const oversized_block_descriptor & other) const
+        {
+            return size == other.size && alignment == other.alignment && pointer == other.pointer;
+        }
+
+        __host__ __device__
+        bool operator<(const oversized_block_descriptor & other) const
+        {
+            return size < other.size || (size == other.size && alignment < other.alignment);
+        }
+    };
+
+    struct equal_pointers
+    {
+    public:
+        __host__ __device__
+        equal_pointers(void_ptr p) : p(p)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.pointer == p;
+        }
+
+    private:
+        void_ptr p;
+    };
+
+    struct matching_alignment
+    {
+    public:
+        __host__ __device__
+        matching_alignment(std::size_t requested) : requested(requested)
+        {
+        }
+
+        __host__ __device__
+        bool operator()(const oversized_block_descriptor & desc) const
+        {
+            return desc.alignment >= requested;
+        }
+
+    private:
+        std::size_t requested;
+    };
+
+    typedef thrust::host_vector<
+        oversized_block_descriptor,
+        allocator<oversized_block_descriptor, Bookkeeper>
+    > oversized_block_vector;
+
+    typedef thrust::host_vector<
+        void_ptr,
+        allocator<void_ptr, Bookkeeper>
+    > pointer_vector;
+
+    struct pool
+    {
+        __host__
+        pool(const pointer_vector & free)
+            : free_blocks(free),
+            previous_allocated_count(0)
+        {
+        }
+
+        __host__
+        pool(const pool & other)
+            : free_blocks(other.free_blocks),
+            previous_allocated_count(other.previous_allocated_count)
+        {
+        }
+
+#if THRUST_CPP_DIALECT >= 2011
+        pool & operator=(const pool &) = default;
+#endif
+
+        __host__
+        ~pool() {}
+
+        pointer_vector free_blocks;
+        std::size_t previous_allocated_count;
+    };
+
+    typedef thrust::host_vector<
+        pool,
+        allocator<pool, Bookkeeper>
+    > pool_vector;
+
+    Upstream * m_upstream;
+    Bookkeeper * m_bookkeeper;
+
+    pool_options m_options;
+    std::size_t m_smallest_block_log2;
+
+    // buckets containing free lists for each pooled size
+    pool_vector m_pools;
+    // list of all allocations from upstream for the above
+    chunk_vector m_allocated;
+    // list of all cached oversized/overaligned blocks that have been returned to the pool to cache
+    oversized_block_vector m_cached_oversized;
+    // list of all oversized/overaligned allocations from upstream
+    oversized_block_vector m_oversized;
+
+public:
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        // reset the buckets
+        for (std::size_t i = 0; i < m_pools.size(); ++i)
+        {
+            m_pools[i].free_blocks.clear();
+            m_pools[i].previous_allocated_count = 0;
+        }
+
+        // deallocate memory allocated for the buckets
+        for (std::size_t i = 0; i < m_allocated.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_allocated[i].pointer,
+                m_allocated[i].size,
+                m_options.alignment);
+        }
+
+        // deallocate cached oversized/overaligned memory
+        for (std::size_t i = 0; i < m_oversized.size(); ++i)
+        {
+            m_upstream->do_deallocate(
+                m_oversized[i].pointer,
+                m_oversized[i].size,
+                m_oversized[i].alignment);
+        }
+
+        m_allocated.clear();
+        m_oversized.clear();
+        m_cached_oversized.clear();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        bytes = (std::max)(bytes, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // an oversized and/or overaligned allocation requested; needs to be allocated separately
+        if (bytes > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            oversized_block_descriptor oversized;
+            oversized.size = bytes;
+            oversized.alignment = alignment;
+
+            if (m_options.cache_oversized && !m_cached_oversized.empty())
+            {
+                typename oversized_block_vector::iterator it = thrust::lower_bound(
+                    thrust::seq,
+                    m_cached_oversized.begin(),
+                    m_cached_oversized.end(),
+                    oversized);
+
+                // if the size is bigger than the requested size by a factor
+                // bigger than or equal to the specified cutoff for size,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t size_factor = (*it).size / bytes;
+                    if (size_factor >= m_options.cached_size_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end() && (*it).alignment < alignment)
+                {
+                    it = find_if(it + 1, m_cached_oversized.end(), matching_alignment(alignment));
+                }
+
+                // if the alignment is bigger than the requested one by a factor
+                // bigger than or equal to the specified cutoff for alignment,
+                // allocate a new block
+                if (it != m_cached_oversized.end())
+                {
+                    std::size_t alignment_factor = (*it).alignment / alignment;
+                    if (alignment_factor >= m_options.cached_alignment_cutoff_factor)
+                    {
+                        it = m_cached_oversized.end();
+                    }
+                }
+
+                if (it != m_cached_oversized.end())
+                {
+                    oversized.pointer = (*it).pointer;
+                    m_cached_oversized.erase(it);
+                    return oversized.pointer;
+                }
+            }
+
+            // no fitting cached block found; allocate a new one that's just up to the specs
+            oversized.pointer = m_upstream->do_allocate(bytes, alignment);
+            m_oversized.push_back(oversized);
+
+            return oversized.pointer;
+        }
+
+        // the request is NOT for oversized and/or overaligned memory
+        // allocate a block from an appropriate bucket
+        std::size_t bytes_log2 = thrust::detail::log2_ri(bytes);
+        std::size_t bucket_idx = bytes_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        // if the free list of the bucket has no elements, allocate a new chunk
+        // and split it into blocks pushed to the free list
+        if (bucket.free_blocks.empty())
+        {
+            std::size_t bucket_size = static_cast<std::size_t>(1) << bytes_log2;
+
+            std::size_t n = bucket.previous_allocated_count;
+            if (n == 0)
+            {
+                n = m_options.min_blocks_per_chunk;
+                if (n < (m_options.min_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.min_bytes_per_chunk >> bytes_log2;
+                }
+            }
+            else
+            {
+                n = n * 3 / 2;
+                if (n > (m_options.max_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.max_bytes_per_chunk >> bytes_log2;
+                }
+                if (n > m_options.max_blocks_per_chunk)
+                {
+                    n = m_options.max_blocks_per_chunk;
+                }
+            }
+
+            bytes = n << bytes_log2;
+
+            assert(n >= m_options.min_blocks_per_chunk);
+            assert(n <= m_options.max_blocks_per_chunk);
+            assert(bytes >= m_options.min_bytes_per_chunk);
+            assert(bytes <= m_options.max_bytes_per_chunk);
+
+            chunk_descriptor allocated;
+            allocated.size = bytes;
+            allocated.pointer = m_upstream->do_allocate(bytes, m_options.alignment);
+            m_allocated.push_back(allocated);
+            bucket.previous_allocated_count = n;
+
+            for (std::size_t i = 0; i < n; ++i)
+            {
+                bucket.free_blocks.push_back(
+                    static_cast<void_ptr>(
+                        static_cast<char_ptr>(allocated.pointer) + i * bucket_size
+                    )
+                );
+            }
+        }
+
+        // allocate a block from the front of the bucket's free list
+        void_ptr ret = bucket.free_blocks.back();
+        bucket.free_blocks.pop_back();
+        return ret;
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        n = (std::max)(n, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // verify that the pointer is at least as aligned as claimed
+        assert(reinterpret_cast<detail::intmax_t>(detail::pointer_traits<void_ptr>::get(p)) % alignment == 0);
+
+        // the deallocated block is oversized and/or overaligned
+        if (n > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            typename oversized_block_vector::iterator it = find_if(m_oversized.begin(), m_oversized.end(), equal_pointers(p));
+            assert(it != m_oversized.end());
+
+            oversized_block_descriptor oversized = *it;
+
+            if (m_options.cache_oversized)
+            {
+                typename oversized_block_vector::iterator position = lower_bound(m_cached_oversized.begin(), m_cached_oversized.end(), oversized);
+                m_cached_oversized.insert(position, oversized);
+                return;
+            }
+
+            m_oversized.erase(it);
+
+            m_upstream->do_deallocate(p, oversized.size, oversized.alignment);
+
+            return;
+        }
+
+        // push the block to the front of the appropriate bucket's free list
+        std::size_t n_log2 = thrust::detail::log2_ri(n);
+        std::size_t bucket_idx = n_log2 - m_smallest_block_log2;
+        pool & bucket = m_pools[bucket_idx];
+
+        bucket.free_blocks.push_back(p);
+    }
+};
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_sync_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_sync_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed81ae4cb84543955bfcaeeb790623ba5c3b6901
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_sync_pool.h
@@ -0,0 +1,117 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file 
+ *  \brief A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <mutex>
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource. Uses \p std::mutex, and therefore requires C++11.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks to be handed off to the user
+ *  \tparam Bookkeeper the type of memory resources that will be used for allocating bookkeeping memory
+ */
+template<typename Upstream, typename Bookkeeper>
+struct disjoint_synchronized_pool_resource : public memory_resource<typename Upstream::pointer>
+{
+    typedef disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> unsync_pool;
+    typedef std::lock_guard<std::mutex> lock_t;
+
+    typedef typename Upstream::pointer void_ptr;
+
+public:
+    /*! Get the default options for a disjoint pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        return unsync_pool::get_default_options();
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param bookkeeper the upstream memory resource for bookkeeping
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(Upstream * upstream, Bookkeeper * bookkeeper,
+        pool_options options = get_default_options())
+        : upstream_pool(upstream, bookkeeper, options)
+    {
+    }
+
+    /*! Constructor. Upstream and bookkeeping resources are obtained by calling \p get_global_resource for their types.
+     *
+     *  \param options pool options to use
+     */
+    disjoint_synchronized_pool_resource(pool_options options = get_default_options())
+        : upstream_pool(get_global_resource<Upstream>(), get_global_resource<Bookkeeper>(), options)
+    {
+    }
+
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        lock_t lock(mtx);
+        upstream_pool.release();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        return upstream_pool.do_allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        upstream_pool.do_deallocate(p, n, alignment);
+    }
+
+private:
+    std::mutex mtx;
+    unsync_pool upstream_pool;
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_tls_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_tls_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fc7917cae102844ab05f1cff08fb001fdfebad6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/disjoint_tls_pool.h
@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/mr/disjoint_pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_management Memory Management
+ *  \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_resources
+ *  \{
+ */
+
+/*! Potentially constructs, if not yet created, and then returns the address of a thread-local
+ *      \p disjoint_unsynchronized_pool_resource,
+ *
+ *  \tparam Upstream the first template argument to the pool template
+ *  \tparam Bookkeeper the second template argument to the pool template
+ *  \param upstream the first argument to the constructor, if invoked
+ *  \param bookkeeper the second argument to the constructor, if invoked
+ */
+template<typename Upstream, typename Bookkeeper>
+__host__
+thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper> & tls_disjoint_pool(
+    Upstream * upstream = NULL,
+    Bookkeeper * bookkeeper = NULL)
+{
+    static thread_local auto adaptor = [&]{
+        assert(upstream && bookkeeper);
+        return thrust::mr::disjoint_unsynchronized_pool_resource<Upstream, Bookkeeper>(upstream, bookkeeper);
+    }();
+
+    return adaptor;
+}
+
+/*! \}
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/fancy_pointer_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/fancy_pointer_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..b88107564096983122c7f61eea4612be4791a65d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/fancy_pointer_resource.h
@@ -0,0 +1,61 @@
+/*
+ *  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>
+#include <thrust/detail/type_traits/pointer_traits.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/validator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename Upstream, typename Pointer>
+class fancy_pointer_resource final : public memory_resource<Pointer>, private validator<Upstream>
+{
+public:
+    fancy_pointer_resource() : m_upstream(get_global_resource<Upstream>())
+    {
+    }
+
+    fancy_pointer_resource(Upstream * upstream) : m_upstream(upstream)
+    {
+    }
+
+    THRUST_NODISCARD
+    virtual Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return static_cast<Pointer>(m_upstream->do_allocate(bytes, alignment));
+    }
+
+    virtual void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        return m_upstream->do_deallocate(
+            static_cast<typename Upstream::pointer>(
+                thrust::detail::pointer_traits<Pointer>::get(p)),
+            bytes, alignment);
+    }
+
+private:
+    Upstream * m_upstream;
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/host_memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/host_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..9359a97a7de79c6a0af389b453baaa32f641d090
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/host_memory_resource.h
@@ -0,0 +1,32 @@
+/*
+ *  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>
+
+// #include the host system's memory_resource header
+#define __THRUST_HOST_SYSTEM_MEMORY_HEADER <__THRUST_HOST_SYSTEM_ROOT/memory_resource.h>
+#include __THRUST_HOST_SYSTEM_MEMORY_HEADER
+#undef __THRUST_HOST_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_HOST_SYSTEM_NAMESPACE::memory_resource
+    host_memory_resource;
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..6af2f167c6460454cb3e659ebab1e99a624a7cec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/memory_resource.h
@@ -0,0 +1,217 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief A base class for the memory resource system, similar to
+ *  std::memory_resource, and related utilities.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/config/memory_resource.h>
+#ifdef THRUST_MR_STD_MR_HEADER
+#  include THRUST_MR_STD_MR_HEADER
+#endif
+
+THRUST_NAMESPACE_BEGIN
+/*! \brief \p thrust::mr is the namespace containing system agnostic types and functions for \p memory_resource related functionalities.
+ */
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! \p memory_resource is the base class for all other memory resources.
+ *
+ *  \tparam Pointer the pointer type that is allocated and deallocated by the memory resource
+ *      derived from this base class. If this is <tt>void *</tt>, this class derives from
+ *      <tt>std::pmr::memory_resource</tt>.
+ */
+template<typename Pointer = void *>
+class memory_resource
+{
+public:
+    /*! Alias for the template parameter.
+     */
+    typedef Pointer pointer;
+
+    /*! Virtual destructor, defaulted when possible.
+     */
+    virtual ~memory_resource() = default;
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the alignment of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    /*! Allocates memory of size at least \p bytes and alignment at least \p alignment.
+     *
+     *  \param bytes size, in bytes, that is requested from this allocation
+     *  \param alignment alignment that is requested from this allocation
+     *  \throws thrust::bad_alloc when no memory with requested size and alignment can be allocated.
+     *  \return A pointer to void to the newly allocated memory.
+     */
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Deallocates memory pointed to by \p p.
+     *
+     *  \param p pointer to be deallocated
+     *  \param bytes the size of the allocation. This must be equivalent to the value of \p bytes that
+     *      was passed to the allocation function that returned \p p.
+     *  \param alignment the size of the allocation. This must be equivalent to the value of \p alignment
+     *      that was passed to the allocation function that returned \p p.
+     */
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+
+    /*! Compares this resource to the other one. The default implementation uses identity comparison,
+     *      which is often the right thing to do and doesn't require RTTI involvement.
+     *
+     *  \param other the other resource to compare this resource to
+     *  \return whether the two resources are equivalent.
+     */
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+};
+
+template<>
+class memory_resource<void *>
+#ifdef THRUST_STD_MR_NS
+    : THRUST_STD_MR_NS::memory_resource
+#endif
+{
+public:
+    typedef void * pointer;
+
+    virtual ~memory_resource() = default;
+
+    THRUST_NODISCARD
+    pointer allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        return do_allocate(bytes, alignment);
+    }
+
+    void deallocate(pointer p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT)
+    {
+        do_deallocate(p, bytes, alignment);
+    }
+
+    __host__ __device__
+    bool is_equal(const memory_resource & other) const noexcept
+    {
+        return do_is_equal(other);
+    }
+
+    virtual pointer do_allocate(std::size_t bytes, std::size_t alignment) = 0;
+    virtual void do_deallocate(pointer p, std::size_t bytes, std::size_t alignment) = 0;
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource & other) const noexcept
+    {
+        return this == &other;
+    }
+
+#ifdef THRUST_STD_MR_NS
+    // the above do_is_equal is a different function than the one from the standard memory resource
+    // can't implement this reasonably without RTTI though; it's reasonable to assume false otherwise
+
+    virtual bool do_is_equal(const THRUST_STD_MR_NS::memory_resource & other) const noexcept override
+    {
+#  ifdef THRUST_HAS_DYNAMIC_CAST
+        auto mr_resource = dynamic_cast<memory_resource<> *>(&other);
+        return mr_resource && do_is_equal(*mr_resource);
+#  else
+        return this == &other;
+#  endif
+    }
+#endif
+};
+
+/*! Compares the memory resources for equality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator==(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return &lhs == &rhs || rhs.is_equal(rhs);
+}
+
+/*! Compares the memory resources for inequality, first by identity, then by \p is_equal.
+ */
+template<typename Pointer>
+__host__ __device__
+bool operator!=(const memory_resource<Pointer> & lhs, const memory_resource<Pointer> & rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+/*! Returns a global instance of \p MR, created as a function local static variable.
+ *
+ *  \tparam MR type of a memory resource to get an instance from. Must be \p DefaultConstructible.
+ *  \return a pointer to a global instance of \p MR.
+ */
+template<typename MR>
+__host__
+MR * get_global_resource()
+{
+    static MR resource;
+    return &resource;
+}
+
+/*! \} // memory_resource
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/new.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/new.h
new file mode 100644
index 0000000000000000000000000000000000000000..644e25169ed2ebea21c6da73ae17a96f24f0aa24
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/new.h
@@ -0,0 +1,89 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file
+ *  \brief Global operator new-based memory resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource that uses global operators new and delete to allocate and deallocate memory. Uses alignment-enabled
+ *      overloads when available, otherwise uses regular overloads and implements alignment requirements by itself.
+ */
+class new_delete_resource final : public memory_resource<>
+{
+public:
+    void * do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+#if defined(__cpp_aligned_new)
+        return ::operator new(bytes, std::align_val_t(alignment));
+#else
+        // allocate memory for bytes, plus potential alignment correction,
+        // plus store of the correction offset
+        void * p = ::operator new(bytes + alignment + sizeof(std::size_t));
+        std::size_t ptr_int = reinterpret_cast<std::size_t>(p);
+        // calculate the offset, i.e. how many bytes of correction was necessary
+        // to get an aligned pointer
+        std::size_t offset = (ptr_int % alignment) ? (alignment - ptr_int % alignment) : 0;
+        // calculate the return pointer
+        char * ptr = static_cast<char *>(p) + offset;
+        // store the offset right after the actually returned value
+        std::size_t * offset_store = reinterpret_cast<std::size_t *>(ptr + bytes);
+        *offset_store = offset;
+        return static_cast<void *>(ptr);
+#endif
+    }
+
+    void do_deallocate(void * p, std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+#if defined(__cpp_aligned_new)
+# if defined(__cpp_sized_deallocation)
+        ::operator delete(p, bytes, std::align_val_t(alignment));
+# else
+        (void)bytes;
+        ::operator delete(p, std::align_val_t(alignment));
+# endif
+#else
+        (void)alignment;
+        char * ptr = static_cast<char *>(p);
+        // calculate where the offset is stored
+        std::size_t * offset = reinterpret_cast<std::size_t *>(ptr + bytes);
+        // calculate the original pointer
+        p = static_cast<void *>(ptr - *offset);
+        ::operator delete(p);
+#endif
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/polymorphic_adaptor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/polymorphic_adaptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..0562a8f82698c58058bd54c97fc744bef9fb4705
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/polymorphic_adaptor.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright 2018-2019 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename Pointer = void *>
+class polymorphic_adaptor_resource final : public memory_resource<Pointer>
+{
+public:
+    polymorphic_adaptor_resource(memory_resource<Pointer> * t) : upstream_resource(t)
+    {
+    }
+
+    virtual Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        return upstream_resource->allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+    {
+        return upstream_resource->deallocate(p, bytes, alignment);
+    }
+
+    __host__ __device__
+    virtual bool do_is_equal(const memory_resource<Pointer> & other) const noexcept override
+    {
+        return upstream_resource->is_equal(other);
+    }
+
+private:
+    memory_resource<Pointer> * upstream_resource;
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..6259a23f172663612ec316771784ab0ba128f648
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool.h
@@ -0,0 +1,507 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file 
+ *  \brief A caching and pooling memory resource adaptor which uses a single
+ *  upstream resource for memory allocation, and embeds bookkeeping information
+ *  in allocated blocks.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/algorithm_wrapper.h>
+
+#include <thrust/host_vector.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/pool_options.h>
+
+#include <cassert>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A memory resource adaptor allowing for pooling and caching allocations from \p Upstream, using memory allocated
+ *      from it for both blocks then allocated to the user and for internal bookkeeping of the cached memory.
+ *
+ *  On a typical memory resource, calls to \p allocate and \p deallocate actually allocate and deallocate memory. Pooling
+ *      memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when
+ *      there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make
+ *      memory allocation faster and more efficient.
+ *
+ *  The non-disjoint version of the pool resource uses a single upstream memory resource. Every allocation is larger than
+ *      strictly necessary to fulfill the end-user's request, because it needs to account for the memory overhead of tracking
+ *      the memory blocks and chunks inside those same memory regions. Nevertheless, this version should be more memory-efficient
+ *      than the \p disjoint_unsynchronized_pool_resource, because it doesn't need to allocate additional blocks of memory
+ *      from a separate resource, which in turn would necessitate the bookkeeping overhead in the upstream resource.
+ *
+ *  This version requires that memory allocated from Upstream is accessible from device. It supports smart references,
+ *      meaning that the non-managed CUDA resource, returning a device-tagged pointer, will work, but will be much less
+ *      efficient than the disjoint version, which wouldn't need to touch device memory at all, and therefore wouldn't need
+ *      to transfer it back and forth between the host and the device whenever an allocation or a deallocation happens.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory blocks
+ */
+template<typename Upstream>
+class unsynchronized_pool_resource final
+    : public memory_resource<typename Upstream::pointer>,
+        private validator<Upstream>
+{
+public:
+    /*! Get the default options for a pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        pool_options ret;
+
+        ret.min_blocks_per_chunk = 16;
+        ret.min_bytes_per_chunk = 1024;
+        ret.max_blocks_per_chunk = static_cast<std::size_t>(1) << 20;
+        ret.max_bytes_per_chunk = static_cast<std::size_t>(1) << 30;
+
+        ret.smallest_block_size = THRUST_MR_DEFAULT_ALIGNMENT;
+        ret.largest_block_size = static_cast<std::size_t>(1) << 20;
+
+        ret.alignment = THRUST_MR_DEFAULT_ALIGNMENT;
+
+        ret.cache_oversized = true;
+
+        ret.cached_size_cutoff_factor = 16;
+        ret.cached_alignment_cutoff_factor = 16;
+
+        return ret;
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param options pool options to use
+     */
+    unsynchronized_pool_resource(Upstream * upstream, pool_options options = get_default_options())
+        : m_upstream(upstream),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(upstream),
+        m_allocated(),
+        m_oversized(),
+        m_cached_oversized()
+    {
+        assert(m_options.validate());
+
+        pool p = { block_descriptor_ptr(), 0 };
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    // TODO: C++11: use delegating constructors
+
+    /*! Constructor. The upstream resource is obtained by calling \p get_global_resource<Upstream>.
+     *
+     *  \param options pool options to use
+     */
+    unsynchronized_pool_resource(pool_options options = get_default_options())
+        : m_upstream(get_global_resource<Upstream>()),
+        m_options(options),
+        m_smallest_block_log2(detail::log2_ri(m_options.smallest_block_size)),
+        m_pools(get_global_resource<Upstream>()),
+        m_allocated(),
+        m_oversized(),
+        m_cached_oversized()
+    {
+        assert(m_options.validate());
+
+        pool p = { block_descriptor_ptr(), 0 };
+        m_pools.resize(detail::log2_ri(m_options.largest_block_size) - m_smallest_block_log2 + 1, p);
+    }
+
+    /*! Destructor. Releases all held memory to upstream.
+     */
+    ~unsynchronized_pool_resource()
+    {
+        release();
+    }
+
+private:
+    typedef typename Upstream::pointer void_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<char>::other char_ptr;
+
+    struct block_descriptor;
+    struct chunk_descriptor;
+    struct oversized_block_descriptor;
+
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<block_descriptor>::other block_descriptor_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<chunk_descriptor>::other chunk_descriptor_ptr;
+    typedef typename thrust::detail::pointer_traits<void_ptr>::template rebind<oversized_block_descriptor>::other oversized_block_descriptor_ptr;
+
+    struct block_descriptor
+    {
+        block_descriptor_ptr next;
+    };
+
+    struct chunk_descriptor
+    {
+        std::size_t size;
+        chunk_descriptor_ptr next;
+    };
+
+    // this was originally a forward list, but I made it a doubly linked list
+    // because that way deallocation when not caching is faster and doesn't require
+    // traversal of a linked list (it's still a forward list for the cached list,
+    // because allocation from that list already traverses)
+    //
+    // TODO: investigate whether it's better to have this be a doubly-linked list
+    // with fast do_deallocate when !m_options.cache_oversized, or to have this be
+    // a forward list and require traversal in do_deallocate
+    //
+    // I assume that it is better this way, but the additional pointer could
+    // potentially hurt? these are supposed to be oversized and/or overaligned,
+    // so they are kinda memory intensive already
+    struct oversized_block_descriptor
+    {
+        std::size_t size;
+        std::size_t alignment;
+        oversized_block_descriptor_ptr prev;
+        oversized_block_descriptor_ptr next;
+        oversized_block_descriptor_ptr next_cached;
+    };
+
+    struct pool
+    {
+        block_descriptor_ptr free_list;
+        std::size_t previous_allocated_count;
+    };
+
+    typedef thrust::host_vector<
+        pool,
+        allocator<pool, Upstream>
+    > pool_vector;
+
+    Upstream * m_upstream;
+
+    pool_options m_options;
+    std::size_t m_smallest_block_log2;
+
+    pool_vector m_pools;
+    chunk_descriptor_ptr m_allocated;
+    oversized_block_descriptor_ptr m_oversized;
+    oversized_block_descriptor_ptr m_cached_oversized;
+
+public:
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        // reset the buckets
+        for (std::size_t i = 0; i < m_pools.size(); ++i)
+        {
+            thrust::raw_reference_cast(m_pools[i]).free_list = block_descriptor_ptr();
+            thrust::raw_reference_cast(m_pools[i]).previous_allocated_count = 0;
+        }
+
+        // deallocate memory allocated for the buckets
+        while (detail::pointer_traits<chunk_descriptor_ptr>::get(m_allocated))
+        {
+            chunk_descriptor_ptr alloc = m_allocated;
+            m_allocated = thrust::raw_reference_cast(*m_allocated).next;
+
+            void_ptr p = static_cast<void_ptr>(
+                static_cast<char_ptr>(
+                    static_cast<void_ptr>(alloc)
+                ) - thrust::raw_reference_cast(*alloc).size
+            );
+            m_upstream->do_deallocate(p, thrust::raw_reference_cast(*alloc).size + sizeof(chunk_descriptor), m_options.alignment);
+        }
+
+        // deallocate cached oversized/overaligned memory
+        while (detail::pointer_traits<oversized_block_descriptor_ptr>::get(m_oversized))
+        {
+            oversized_block_descriptor_ptr alloc = m_oversized;
+            m_oversized = thrust::raw_reference_cast(*m_oversized).next;
+
+            void_ptr p = static_cast<void_ptr>(
+                static_cast<char_ptr>(
+                    static_cast<void_ptr>(alloc)
+                ) - thrust::raw_reference_cast(*alloc).size
+            );
+            m_upstream->do_deallocate(p, thrust::raw_reference_cast(*alloc).size + sizeof(oversized_block_descriptor), thrust::raw_reference_cast(*alloc).alignment);
+        }
+
+        m_cached_oversized = oversized_block_descriptor_ptr();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        bytes = (std::max)(bytes, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // an oversized and/or overaligned allocation requested; needs to be allocated separately
+        if (bytes > m_options.largest_block_size || alignment > m_options.alignment)
+        {
+            if (m_options.cache_oversized)
+            {
+                oversized_block_descriptor_ptr ptr = m_cached_oversized;
+                oversized_block_descriptor_ptr * previous = &m_cached_oversized;
+                while (detail::pointer_traits<oversized_block_descriptor_ptr>::get(ptr))
+                {
+                    oversized_block_descriptor desc = *ptr;
+                    bool is_good = desc.size >= bytes && desc.alignment >= alignment;
+
+                    // if the size is bigger than the requested size by a factor
+                    // bigger than or equal to the specified cutoff for size,
+                    // allocate a new block
+                    if (is_good)
+                    {
+                        std::size_t size_factor = desc.size / bytes;
+                        if (size_factor >= m_options.cached_size_cutoff_factor)
+                        {
+                            is_good = false;
+                        }
+                    }
+
+                    // if the alignment is bigger than the requested one by a factor
+                    // bigger than or equal to the specified cutoff for alignment,
+                    // allocate a new block
+                    if (is_good)
+                    {
+                        std::size_t alignment_factor = desc.alignment / alignment;
+                        if (alignment_factor >= m_options.cached_alignment_cutoff_factor)
+                        {
+                            is_good = false;
+                        }
+                    }
+
+                    if (is_good)
+                    {
+                        if (previous != &m_cached_oversized)
+                        {
+                            oversized_block_descriptor previous_desc = **previous;
+                            previous_desc.next_cached = desc.next_cached;
+                            **previous = previous_desc;
+                        }
+                        else
+                        {
+                            m_cached_oversized = desc.next_cached;
+                        }
+
+                        desc.next_cached = oversized_block_descriptor_ptr();
+                        *ptr = desc;
+
+                        return static_cast<void_ptr>(
+                            static_cast<char_ptr>(
+                                static_cast<void_ptr>(ptr)
+                            ) - desc.size
+                        );
+                    }
+
+                    previous = &thrust::raw_reference_cast(*ptr).next_cached;
+                    ptr = *previous;
+                }
+            }
+
+            // no fitting cached block found; allocate a new one that's just up to the specs
+            void_ptr allocated = m_upstream->do_allocate(bytes + sizeof(oversized_block_descriptor), alignment);
+            oversized_block_descriptor_ptr block = static_cast<oversized_block_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(allocated) + bytes
+                )
+            );
+
+            oversized_block_descriptor desc;
+            desc.size = bytes;
+            desc.alignment = alignment;
+            desc.prev = oversized_block_descriptor_ptr();
+            desc.next = m_oversized;
+            desc.next_cached = oversized_block_descriptor_ptr();
+            *block = desc;
+            m_oversized = block;
+
+            if (detail::pointer_traits<oversized_block_descriptor_ptr>::get(desc.next))
+            {
+                oversized_block_descriptor next = *desc.next;
+                next.prev = block;
+                *desc.next = next;
+            }
+
+            return allocated;
+        }
+
+        // the request is NOT for oversized and/or overaligned memory
+        // allocate a block from an appropriate bucket
+        std::size_t bytes_log2 = thrust::detail::log2_ri(bytes);
+        std::size_t bucket_idx = bytes_log2 - m_smallest_block_log2;
+        pool & bucket = thrust::raw_reference_cast(m_pools[bucket_idx]);
+
+        bytes = static_cast<std::size_t>(1) << bytes_log2;
+
+        // if the free list of the bucket has no elements, allocate a new chunk
+        // and split it into blocks pushed to the free list
+        if (!detail::pointer_traits<block_descriptor_ptr>::get(bucket.free_list))
+        {
+            std::size_t n = bucket.previous_allocated_count;
+            if (n == 0)
+            {
+                n = m_options.min_blocks_per_chunk;
+                if (n < (m_options.min_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.min_bytes_per_chunk >> bytes_log2;
+                }
+            }
+            else
+            {
+                n = n * 3 / 2;
+                if (n > (m_options.max_bytes_per_chunk >> bytes_log2))
+                {
+                    n = m_options.max_bytes_per_chunk >> bytes_log2;
+                }
+                if (n > m_options.max_blocks_per_chunk)
+                {
+                    n = m_options.max_blocks_per_chunk;
+                }
+            }
+
+            std::size_t descriptor_size = (std::max)(sizeof(block_descriptor), m_options.alignment);
+            std::size_t block_size = bytes + descriptor_size;
+            block_size += m_options.alignment - block_size % m_options.alignment;
+            std::size_t chunk_size = block_size * n;
+
+            void_ptr allocated = m_upstream->do_allocate(chunk_size + sizeof(chunk_descriptor), m_options.alignment);
+            chunk_descriptor_ptr chunk = static_cast<chunk_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(allocated) + chunk_size
+                )
+            );
+
+            chunk_descriptor chunk_desc;
+            chunk_desc.size = chunk_size;
+            chunk_desc.next = m_allocated;
+            *chunk = chunk_desc;
+            m_allocated = chunk;
+
+            for (std::size_t i = 0; i < n; ++i)
+            {
+                block_descriptor_ptr block = static_cast<block_descriptor_ptr>(
+                    static_cast<void_ptr>(
+                        static_cast<char_ptr>(allocated) + block_size * i + bytes
+                    )
+                );
+
+                block_descriptor block_desc;
+                block_desc.next = bucket.free_list;
+                *block = block_desc;
+                bucket.free_list = block;
+            }
+        }
+
+        // allocate a block from the front of the bucket's free list
+        block_descriptor_ptr block = bucket.free_list;
+        bucket.free_list = thrust::raw_reference_cast(*block).next;
+        return static_cast<void_ptr>(
+            static_cast<char_ptr>(
+                static_cast<void_ptr>(block)
+            ) - bytes
+        );
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        n = (std::max)(n, m_options.smallest_block_size);
+        assert(detail::is_power_of_2(alignment));
+
+        // verify that the pointer is at least as aligned as claimed
+        assert(reinterpret_cast<detail::intmax_t>(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)
+        {
+            oversized_block_descriptor_ptr block = static_cast<oversized_block_descriptor_ptr>(
+                static_cast<void_ptr>(
+                    static_cast<char_ptr>(p) + n
+                )
+            );
+
+            oversized_block_descriptor desc = *block;
+
+            if (m_options.cache_oversized)
+            {
+                desc.next_cached = m_cached_oversized;
+                *block = desc;
+                m_cached_oversized = block;
+
+                return;
+            }
+
+            if (!detail::pointer_traits<oversized_block_descriptor_ptr>::get(desc.prev))
+            {
+                assert(m_oversized == block);
+                m_oversized = desc.next;
+            }
+            else
+            {
+                oversized_block_descriptor prev = *desc.prev;
+                assert(prev.next == block);
+                prev.next = desc.next;
+                *desc.prev = prev;
+            }
+
+            if (detail::pointer_traits<oversized_block_descriptor_ptr>::get(desc.next))
+            {
+                oversized_block_descriptor next = *desc.next;
+                assert(next.prev == block);
+                next.prev = desc.prev;
+                *desc.next = next;
+            }
+
+            m_upstream->do_deallocate(p, desc.size + sizeof(oversized_block_descriptor), desc.alignment);
+
+            return;
+        }
+
+        // push the block to the front of the appropriate bucket's free list
+        std::size_t n_log2 = thrust::detail::log2_ri(n);
+        std::size_t bucket_idx = n_log2 - m_smallest_block_log2;
+        pool & bucket = thrust::raw_reference_cast(m_pools[bucket_idx]);
+
+        n = static_cast<std::size_t>(1) << n_log2;
+
+        block_descriptor_ptr block = static_cast<block_descriptor_ptr>(
+            static_cast<void_ptr>(
+                static_cast<char_ptr>(p) + n
+            )
+        );
+
+        block_descriptor desc;
+        desc.next = bucket.free_list;
+        *block = desc;
+        bucket.free_list = block;
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..13a8fe67400e18fbf73ae8e190d115e205850d7b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/pool_options.h
@@ -0,0 +1,128 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file 
+ *  \brief A type used by the pooling resource adaptors to fine-tune their
+ *  behavior.
+ */
+
+#pragma once
+
+#include <cstddef>
+
+#include <thrust/detail/integer_math.h>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/config/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A type used for configuring pooling resource adaptors, to fine-tune their behavior and parameters.
+ */
+struct pool_options
+{
+    /*! The minimal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
+     *      chunk allocated from upstream.
+     */
+    std::size_t min_blocks_per_chunk;
+    /*! The minimal number of bytes in a single chunk allocated from upstream.
+     */
+    std::size_t min_bytes_per_chunk;
+    /*! The maximal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
+     *      chunk allocated from upstream.
+     */
+    std::size_t max_blocks_per_chunk;
+    /*! The maximal number of bytes in a single chunk allocated from upstream.
+     */
+    std::size_t max_bytes_per_chunk;
+
+    /*! The size of blocks in the smallest pool covered by the pool resource. All allocation requests below this size will
+     *      be rounded up to this size.
+     */
+    std::size_t smallest_block_size;
+    /*! The size of blocks in the largest pool covered by the pool resource. All allocation requests above this size will
+     *      be considered oversized, allocated directly from upstream (and not from a pool), and cached only of \p cache_oversized
+     *      is true.
+     */
+    std::size_t largest_block_size;
+
+    /*! The alignment of all blocks in internal pools of the pool resource. All allocation requests above this alignment
+     *      will be considered oversized, allocated directly from upstream (and not from a pool), and cached only of
+     *      \p cache_oversized is true.
+     */
+    std::size_t alignment;
+
+    /*! Decides whether oversized and overaligned blocks are cached for later use, or immediately return it to the upstream
+     *      resource.
+     */
+    bool cache_oversized;
+
+    /*! The size factor at which a cached allocation is considered too ridiculously oversized to use to fulfill an allocation
+     *      request. For instance: the user requests an allocation of size 1024 bytes. A block of size 32 * 1024 bytes is
+     *      cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too big for that allocation
+     *      request.
+     */
+    std::size_t cached_size_cutoff_factor;
+    /*! The alignment factor at which a cached allocation is considered too ridiculously overaligned to use to fulfill an
+     *      allocation request. For instance: the user requests an allocation aligned to 32 bytes. A block aligned to 1024 bytes
+     *      is cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too overaligned for that
+     *      allocation request.
+     */
+    std::size_t cached_alignment_cutoff_factor;
+
+    /*! Checks if the options are self-consistent.
+     *
+     *  /returns true if the options are self-consitent, false otherwise.
+     */
+    bool validate() const
+    {
+        if (!detail::is_power_of_2(smallest_block_size)) return false;
+        if (!detail::is_power_of_2(largest_block_size)) return false;
+        if (!detail::is_power_of_2(alignment)) return false;
+
+        if (max_bytes_per_chunk == 0 || max_blocks_per_chunk == 0) return false;
+        if (smallest_block_size == 0 || largest_block_size == 0) return false;
+
+        if (min_blocks_per_chunk > max_blocks_per_chunk) return false;
+        if (min_bytes_per_chunk > max_bytes_per_chunk) return false;
+
+        if (smallest_block_size > largest_block_size) return false;
+
+        if (min_blocks_per_chunk * smallest_block_size > max_bytes_per_chunk) return false;
+        if (min_blocks_per_chunk * largest_block_size > max_bytes_per_chunk) return false;
+
+        if (max_blocks_per_chunk * largest_block_size < min_bytes_per_chunk) return false;
+        if (max_blocks_per_chunk * smallest_block_size < min_bytes_per_chunk) return false;
+
+        if (alignment > smallest_block_size) return false;
+
+        return true;
+    }
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/sync_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/sync_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..46c0e8441370982a4c8cbbe1c1c49cb73a931704
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/sync_pool.h
@@ -0,0 +1,114 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file 
+ *  \brief A mutex-synchronized version of \p unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <mutex>
+
+#include <thrust/mr/pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! A mutex-synchronized version of \p unsynchronized_pool_resource. Uses \p std::mutex, and therefore requires C++11.
+ *
+ *  \tparam Upstream the type of memory resources that will be used for allocating memory
+ */
+template<typename Upstream>
+struct synchronized_pool_resource : public memory_resource<typename Upstream::pointer>
+{
+    typedef unsynchronized_pool_resource<Upstream> unsync_pool;
+    typedef std::lock_guard<std::mutex> lock_t;
+
+    typedef typename Upstream::pointer void_ptr;
+
+public:
+    /*! Get the default options for a pool. These are meant to be a sensible set of values for many use cases,
+     *      and as such, may be tuned in the future. This function is exposed so that creating a set of options that are
+     *      just a slight departure from the defaults is easy.
+     */
+    static pool_options get_default_options()
+    {
+        return unsync_pool::get_default_options();
+    }
+
+    /*! Constructor.
+     *
+     *  \param upstream the upstream memory resource for allocations
+     *  \param options pool options to use
+     */
+    synchronized_pool_resource(Upstream * upstream, pool_options options = get_default_options())
+        : upstream_pool(upstream, options)
+    {
+    }
+
+    /*! Constructor. The upstream resource is obtained by calling \p get_global_resource<Upstream>.
+     *
+     *  \param options pool options to use
+     */
+    synchronized_pool_resource(pool_options options = get_default_options())
+        : upstream_pool(get_global_resource<Upstream>(), options)
+    {
+    }
+
+    /*! Releases all held memory to upstream.
+     */
+    void release()
+    {
+        lock_t lock(mtx);
+        upstream_pool.release();
+    }
+
+    THRUST_NODISCARD virtual void_ptr do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        return upstream_pool.do_allocate(bytes, alignment);
+    }
+
+    virtual void do_deallocate(void_ptr p, std::size_t n, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+    {
+        lock_t lock(mtx);
+        upstream_pool.do_deallocate(p, n, alignment);
+    }
+
+private:
+    std::mutex mtx;
+    unsync_pool upstream_pool;
+};
+
+/*! \} // memory_resources
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/tls_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/tls_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ee8127a3d7afb6fcbff3922a6fbfbc0bc27dc0a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/tls_pool.h
@@ -0,0 +1,64 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file tls_pool.h
+ *  \brief A function wrapping a thread local instance of a \p unsynchronized_pool_resource.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/mr/pool.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+/*! \addtogroup memory_management Memory Management
+ *  \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_resources
+ *  \{
+ */
+
+/*! Potentially constructs, if not yet created, and then returns the address of a thread-local \p unsynchronized_pool_resource,
+ *
+ *  \tparam Upstream the template argument to the pool template
+ *  \param upstream the argument to the constructor, if invoked
+ */
+template<typename Upstream, typename Bookkeeper>
+__host__
+thrust::mr::unsynchronized_pool_resource<Upstream> & tls_pool(Upstream * upstream = NULL)
+{
+    static thread_local auto adaptor = [&]{
+        assert(upstream);
+        return thrust::mr::unsynchronized_pool_resource<Upstream>(upstream);
+    }();
+
+    return adaptor;
+}
+
+/*! \}
+ */
+
+} // end mr
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/universal_memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/universal_memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7f1ebd6f468efba2ef6104451fa2975a04335bf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/universal_memory_resource.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+#include <thrust/mr/device_memory_resource.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/validator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/validator.h
new file mode 100644
index 0000000000000000000000000000000000000000..10e964821a5b47cd34f58380de04393dc23bfe17
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/mr/validator.h
@@ -0,0 +1,51 @@
+/*
+ *  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>
+
+#include <thrust/detail/config/memory_resource.h>
+#include <thrust/mr/memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace mr
+{
+
+template<typename MR>
+struct validator
+{
+#if THRUST_CPP_DIALECT >= 2011
+  static_assert(
+    std::is_base_of<memory_resource<typename MR::pointer>, MR>::value,
+    "a type used as a memory resource must derive from memory_resource"
+  );
+#endif
+};
+
+template<typename T, typename U>
+struct validator2 : private validator<T>, private validator<U>
+{
+};
+
+template<typename T>
+struct validator2<T, T> : private validator<T>
+{
+};
+
+} // end mr
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/optional.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/optional.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1ca4f46554b87666863bb64be6e2d40fbd3a38a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/optional.h
@@ -0,0 +1,2876 @@
+///
+// optional - An implementation of std::optional with extensions
+// Written in 2017 by Sy Brand (@TartanLlama)
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to the
+// public domain worldwide. This software is distributed without any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software. If not, see
+// <http://creativecommons.org/publicdomain/zero/1.0/>.
+///
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+#include <thrust/detail/type_traits.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/addressof.h>
+#include <thrust/swap.h>
+
+#define THRUST_OPTIONAL_VERSION_MAJOR 0
+#define THRUST_OPTIONAL_VERSION_MINOR 2
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && _MSC_VER == 1900)
+#define THRUST_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
+     !defined(__clang__))
+#define THRUST_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 &&              \
+     !defined(__clang__))
+#define THRUST_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 &&              \
+     !defined(__clang__))
+#define THRUST_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
+     !defined(__clang__))
+// GCC < 5 doesn't support overloading on const&& for member functions
+#define THRUST_OPTIONAL_NO_CONSTRR
+
+// GCC < 5 doesn't support some standard C++11 type traits
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                                     \
+  std::has_trivial_copy_constructor<T>::value
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+// GCC < 5 doesn't provide a way to emulate std::is_trivially_move_*,
+// so don't enable any optimizations that rely on them:
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) false
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) false
+
+// This one will be different for GCC 5.7 if it's ever supported
+#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector
+// for non-copyable types
+#elif (defined(__GNUC__) && __GNUC__ < 8 &&                                                \
+     !defined(__clang__))
+#ifndef THRUST_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define THRUST_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+THRUST_NAMESPACE_BEGIN
+  namespace detail {
+      template<class T>
+      struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T>{};
+#ifdef _GLIBCXX_VECTOR
+      template<class T, class A>
+      struct is_trivially_copy_constructible<std::vector<T,A>>
+          : std::is_trivially_copy_constructible<T>{};
+#endif
+  }
+THRUST_NAMESPACE_END
+#endif
+
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                                     \
+    thrust::detail::is_trivially_copy_constructible<T>::value
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                                        \
+  std::is_trivially_copy_assignable<T>::value
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T)                                     \
+  std::is_trivially_move_constructible<T>::value
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)                                        \
+  std::is_trivially_move_assignable<T>::value
+#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+
+// To support clang + old libstdc++ without type traits, check for equivalent
+// clang built-ins and use them if present. See note above
+// is_trivially_copyable_impl in
+// thrust/type_traits/is_trivially_relocatable.h for more details.
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+#if defined(__GLIBCXX__) && __has_feature(is_trivially_constructible)
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
+  __is_trivially_constructible(T, T const&)
+#else
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
+  std::is_trivially_copy_constructible<T>::value
+#endif
+
+#if defined(__GLIBCXX__) && __has_feature(is_trivially_assignable)
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+  __is_trivially_assignable(T&, T const&)
+#else
+#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+  std::is_trivially_copy_assignable<T>::value
+#endif
+
+#if defined(__GLIBCXX__) && __has_feature(is_trivially_constructible)
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
+  __is_trivially_constructible(T, T&&)
+#else
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
+  std::is_trivially_move_constructible<T>::value
+#endif
+
+#if defined(__GLIBCXX__) && __has_feature(is_trivially_assignable)
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) \
+  __is_trivially_assignable(T&, T&&)
+#else
+#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) \
+  std::is_trivially_move_assignable<T>::value
+#endif
+
+#if defined(__GLIBCXX__) && __has_feature(is_trivially_destructible)
+#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+  __is_trivially_destructible(T)
+#else
+#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+  std::is_trivially_destructible<T>::value
+#endif
+
+#endif
+
+#if THRUST_CPP_DIALECT > 2011
+#define THRUST_OPTIONAL_CPP14
+#endif
+
+// constexpr implies const in C++11, not C++14
+#if (THRUST_CPP_DIALECT == 2011 || defined(THRUST_OPTIONAL_MSVC2015) ||                \
+     defined(THRUST_OPTIONAL_GCC49))
+/// \exclude
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR
+#else
+/// \exclude
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR constexpr
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+#ifndef THRUST_MONOSTATE_INPLACE_MUTEX
+#define THRUST_MONOSTATE_INPLACE_MUTEX
+/// \brief Used to represent an optional with no data; essentially a bool
+class monostate {};
+
+/// \brief A tag type to tell optional to construct its value in-place
+struct in_place_t {
+  explicit in_place_t() = default;
+};
+/// \brief A tag to tell optional to construct its value in-place
+static constexpr in_place_t in_place{};
+#endif
+
+template <class T> class optional;
+
+/// \exclude
+namespace detail {
+#ifndef THRUST_TRAITS_MUTEX
+#define THRUST_TRAITS_MUTEX
+// C++14-style aliases for brevity
+template <class T> using remove_const_t = typename std::remove_const<T>::type;
+template <class T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template <class T> using decay_t = typename std::decay<T>::type;
+template <bool E, class T = void>
+using enable_if_t = typename std::enable_if<E, T>::type;
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+// std::conjunction from C++17
+template <class...> struct conjunction : std::true_type {};
+template <class B> struct conjunction<B> : B {};
+template <class B, class... Bs>
+struct conjunction<B, Bs...>
+    : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
+
+#if defined(_LIBCPP_VERSION) && THRUST_CPP_DIALECT == 2011
+#define THRUST_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+// In C++11 mode, there's an issue in libc++'s std::mem_fn
+// which results in a hard-error when using it in a noexcept expression
+// in some cases. This is a check to workaround the common failing case.
+#ifdef THRUST_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+template <class T> struct is_pointer_to_non_const_member_func : std::false_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> : std::true_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> : std::true_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> : std::true_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile> : std::true_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&> : std::true_type{};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&&> : std::true_type{};
+
+template <class T> struct is_const_or_const_ref : std::false_type{};
+template <class T> struct is_const_or_const_ref<T const&> : std::true_type{};
+template <class T> struct is_const_or_const_ref<T const> : std::true_type{};
+#endif
+
+// std::invoke from C++17
+// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+__thrust_exec_check_disable__
+template <typename Fn, typename... Args,
+#ifdef THRUST_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+          typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value
+                                 && is_const_or_const_ref<Args...>::value)>,
+#endif
+          typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
+          int = 0>
+__host__ __device__
+constexpr auto invoke(Fn &&f, Args &&... args)
+  noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+  THRUST_TRAILING_RETURN(decltype(std::mem_fn(f)(std::forward<Args>(args)...)))
+{
+  return std::mem_fn(f)(std::forward<Args>(args)...);
+}
+
+__thrust_exec_check_disable__
+template <typename Fn, typename... Args,
+          typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+__host__ __device__
+constexpr auto invoke(Fn &&f, Args &&... args)
+  noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+  THRUST_TRAILING_RETURN(decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+{
+  return std::forward<Fn>(f)(std::forward<Args>(args)...);
+}
+#endif
+
+// std::void_t from C++17
+template <class...> struct voider { using type = void; };
+template <class... Ts> using void_t = typename voider<Ts...>::type;
+
+// Trait for checking if a type is a thrust::optional
+template <class T> struct is_optional_impl : std::false_type {};
+template <class T> struct is_optional_impl<optional<T>> : std::true_type {};
+template <class T> using is_optional = is_optional_impl<decay_t<T>>;
+
+// Change void to thrust::monostate
+template <class U>
+using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+template <class F, class U, class = invoke_result_t<F, U>>
+using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+// Check if invoking F for some Us returns void
+template <class F, class = void, class... U> struct returns_void_impl;
+template <class F, class... U>
+struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
+    : std::is_void<invoke_result_t<F, U...>> {};
+template <class F, class... U>
+using returns_void = returns_void_impl<F, void, U...>;
+
+template <class T, class... U>
+using enable_if_ret_void = enable_if_t<returns_void<T &&, U...>::value>;
+
+template <class T, class... U>
+using disable_if_ret_void = enable_if_t<!returns_void<T &&, U...>::value>;
+
+template <class T, class U>
+using enable_forward_value =
+    detail::enable_if_t<std::is_constructible<T, U &&>::value &&
+                        !std::is_same<detail::decay_t<U>, in_place_t>::value &&
+                        !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+template <class T, class U, class Other>
+using enable_from_other = detail::enable_if_t<
+    std::is_constructible<T, Other>::value &&
+    !std::is_constructible<T, optional<U> &>::value &&
+    !std::is_constructible<T, optional<U> &&>::value &&
+    !std::is_constructible<T, const optional<U> &>::value &&
+    !std::is_constructible<T, const optional<U> &&>::value &&
+    !std::is_convertible<optional<U> &, T>::value &&
+    !std::is_convertible<optional<U> &&, T>::value &&
+    !std::is_convertible<const optional<U> &, T>::value &&
+    !std::is_convertible<const optional<U> &&, T>::value>;
+
+template <class T, class U>
+using enable_assign_forward = detail::enable_if_t<
+    !std::is_same<optional<T>, detail::decay_t<U>>::value &&
+    !detail::conjunction<std::is_scalar<T>,
+                         std::is_same<T, detail::decay_t<U>>>::value &&
+    std::is_constructible<T, U>::value && std::is_assignable<T &, U>::value>;
+
+template <class T, class U, class Other>
+using enable_assign_from_other = detail::enable_if_t<
+    std::is_constructible<T, Other>::value &&
+    std::is_assignable<T &, Other>::value &&
+    !std::is_constructible<T, optional<U> &>::value &&
+    !std::is_constructible<T, optional<U> &&>::value &&
+    !std::is_constructible<T, const optional<U> &>::value &&
+    !std::is_constructible<T, const optional<U> &&>::value &&
+    !std::is_convertible<optional<U> &, T>::value &&
+    !std::is_convertible<optional<U> &&, T>::value &&
+    !std::is_convertible<const optional<U> &, T>::value &&
+    !std::is_convertible<const optional<U> &&, T>::value &&
+    !std::is_assignable<T &, optional<U> &>::value &&
+    !std::is_assignable<T &, optional<U> &&>::value &&
+    !std::is_assignable<T &, const optional<U> &>::value &&
+    !std::is_assignable<T &, const optional<U> &&>::value>;
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+// TODO make a version which works with MSVC
+template <class T, class U = T> struct is_swappable : std::true_type {};
+
+template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
+#else
+// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+namespace swap_adl_tests {
+// if swap ADL finds this then it would call std::swap otherwise (same
+// signature)
+struct tag {};
+
+template <class T> tag swap(T &, T &);
+template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
+
+// helper functions to test if an unqualified swap is possible, and if it
+// becomes std::swap
+template <class, class> std::false_type can_swap(...) noexcept(false);
+template <class T, class U,
+          class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
+std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
+                                                    std::declval<U &>())));
+
+template <class, class> std::false_type uses_std(...);
+template <class T, class U>
+std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
+uses_std(int);
+
+template <class T>
+struct is_std_swap_noexcept
+    : std::integral_constant<bool,
+                             std::is_nothrow_move_constructible<T>::value &&
+                                 std::is_nothrow_move_assignable<T>::value> {};
+
+template <class T, std::size_t N>
+struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
+
+template <class T, class U>
+struct is_adl_swap_noexcept
+    : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
+} // namespace swap_adl_tests
+
+template <class T, class U = T>
+struct is_swappable
+    : std::integral_constant<
+          bool,
+          decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
+              (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
+               (std::is_move_assignable<T>::value &&
+                std::is_move_constructible<T>::value))> {};
+
+template <class T, std::size_t N>
+struct is_swappable<T[N], T[N]>
+    : std::integral_constant<
+          bool,
+          decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
+              (!decltype(
+                   detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value ||
+               is_swappable<T, T>::value)> {};
+
+template <class T, class U = T>
+struct is_nothrow_swappable
+    : std::integral_constant<
+          bool,
+          is_swappable<T, U>::value &&
+              ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+                    &&detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
+               (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
+                    detail::swap_adl_tests::is_adl_swap_noexcept<T,
+                                                                 U>::value))> {
+};
+#endif
+
+// The storage base manages the actual storage, and correctly propagates
+// trivial destruction from T. This case is for when T is not trivially
+// destructible.
+template <class T, bool = ::std::is_trivially_destructible<T>::value>
+struct optional_storage_base {
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional_storage_base() noexcept
+      : m_dummy(), m_has_value(false) {}
+
+  __thrust_exec_check_disable__
+  template <class... U>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
+      : m_value(std::forward<U>(u)...), m_has_value(true) {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ~optional_storage_base() {
+    if (m_has_value) {
+      m_value.~T();
+      m_has_value = false;
+    }
+  }
+
+  struct dummy {};
+  union {
+    dummy m_dummy;
+    T m_value;
+  };
+
+  bool m_has_value;
+};
+
+// This case is for when T is trivially destructible.
+template <class T> struct optional_storage_base<T, true> {
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional_storage_base() noexcept
+      : m_dummy(), m_has_value(false) {}
+
+  __thrust_exec_check_disable__
+  template <class... U>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
+      : m_value(std::forward<U>(u)...), m_has_value(true) {}
+
+  // No destructor, so this class is trivially destructible
+
+  struct dummy {};
+  union {
+    dummy m_dummy;
+    T m_value;
+  };
+
+  bool m_has_value = false;
+};
+
+// This base class provides some handy member functions which can be used in
+// further derived classes
+template <class T> struct optional_operations_base : optional_storage_base<T> {
+  using optional_storage_base<T>::optional_storage_base;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void hard_reset() noexcept {
+    get().~T();
+    this->m_has_value = false;
+  }
+
+  __thrust_exec_check_disable__
+  template <class... Args>
+  __host__ __device__
+  void construct(Args &&... args) noexcept {
+    new (thrust::addressof(this->m_value)) T(std::forward<Args>(args)...);
+    this->m_has_value = true;
+  }
+
+  __thrust_exec_check_disable__
+  template <class Opt>
+  __host__ __device__
+  void assign(Opt &&rhs) {
+    if (this->has_value()) {
+      if (rhs.has_value()) {
+        this->m_value = std::forward<Opt>(rhs).get();
+      } else {
+        this->m_value.~T();
+        this->m_has_value = false;
+      }
+    }
+
+    if (rhs.has_value()) {
+      construct(std::forward<Opt>(rhs).get());
+    }
+  }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  bool has_value() const { return this->m_has_value; }
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &get() & { return this->m_value; }
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR const T &get() const & { return this->m_value; }
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &&get() && { return std::move(this->m_value); }
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T &&get() const && { return std::move(this->m_value); }
+#endif
+};
+
+// This class manages conditionally having a trivial copy constructor
+// This specialization is for when T is trivially copy constructible
+template <class T, bool = THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+struct optional_copy_base : optional_operations_base<T> {
+  using optional_operations_base<T>::optional_operations_base;
+};
+
+// This specialization is for when T is not trivially copy constructible
+template <class T>
+struct optional_copy_base<T, false> : optional_operations_base<T> {
+  using optional_operations_base<T>::optional_operations_base;
+
+  __thrust_exec_check_disable__
+  optional_copy_base() = default;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional_copy_base(const optional_copy_base &rhs) {
+    if (rhs.has_value()) {
+      this->construct(rhs.get());
+    } else {
+      this->m_has_value = false;
+    }
+  }
+
+  __thrust_exec_check_disable__
+  optional_copy_base(optional_copy_base &&rhs) = default;
+  __thrust_exec_check_disable__
+  optional_copy_base &operator=(const optional_copy_base &rhs) = default;
+  __thrust_exec_check_disable__
+  optional_copy_base &operator=(optional_copy_base &&rhs) = default;
+};
+
+template <class T, bool = THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T)>
+struct optional_move_base : optional_copy_base<T> {
+  using optional_copy_base<T>::optional_copy_base;
+};
+template <class T> struct optional_move_base<T, false> : optional_copy_base<T> {
+  using optional_copy_base<T>::optional_copy_base;
+
+  __thrust_exec_check_disable__
+  optional_move_base() = default;
+  __thrust_exec_check_disable__
+  optional_move_base(const optional_move_base &rhs) = default;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional_move_base(optional_move_base &&rhs) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
+    if (rhs.has_value()) {
+      this->construct(std::move(rhs.get()));
+    } else {
+      this->m_has_value = false;
+    }
+  }
+  __thrust_exec_check_disable__
+  optional_move_base &operator=(const optional_move_base &rhs) = default;
+  __thrust_exec_check_disable__
+  optional_move_base &operator=(optional_move_base &&rhs) = default;
+};
+
+// This class manages conditionally having a trivial copy assignment operator
+template <class T, bool = THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) &&
+                          THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) &&
+                          THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+struct optional_copy_assign_base : optional_move_base<T> {
+  using optional_move_base<T>::optional_move_base;
+};
+
+template <class T>
+struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+  using optional_move_base<T>::optional_move_base;
+
+  __thrust_exec_check_disable__
+  optional_copy_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_copy_assign_base(const optional_copy_assign_base &rhs) = default;
+
+  __thrust_exec_check_disable__
+  optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional_copy_assign_base &operator=(const optional_copy_assign_base &rhs) {
+    this->assign(rhs);
+    return *this;
+  }
+  __thrust_exec_check_disable__
+  optional_copy_assign_base &
+  operator=(optional_copy_assign_base &&rhs) = default;
+};
+
+template <class T,
+          bool = THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) &&
+                 THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) &&
+                 THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T)>
+struct optional_move_assign_base : optional_copy_assign_base<T> {
+  using optional_copy_assign_base<T>::optional_copy_assign_base;
+};
+
+template <class T>
+struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+  using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+  __thrust_exec_check_disable__
+  optional_move_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_move_assign_base(const optional_move_assign_base &rhs) = default;
+
+  __thrust_exec_check_disable__
+  optional_move_assign_base(optional_move_assign_base &&rhs) = default;
+
+  __thrust_exec_check_disable__
+  optional_move_assign_base &
+  operator=(const optional_move_assign_base &rhs) = default;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional_move_assign_base &
+  operator=(optional_move_assign_base &&rhs) noexcept(
+      std::is_nothrow_move_constructible<T>::value
+          &&std::is_nothrow_move_assignable<T>::value) {
+    this->assign(std::move(rhs));
+    return *this;
+  }
+};
+
+// optional_delete_ctor_base will conditionally delete copy and move
+// constructors depending on whether T is copy/move constructible
+template <class T, bool EnableCopy = std::is_copy_constructible<T>::value,
+          bool EnableMove = std::is_move_constructible<T>::value>
+struct optional_delete_ctor_base {
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(optional_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T> struct optional_delete_ctor_base<T, true, false> {
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(optional_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T> struct optional_delete_ctor_base<T, false, true> {
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(optional_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T> struct optional_delete_ctor_base<T, false, false> {
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(const optional_delete_ctor_base &) = delete;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(const optional_delete_ctor_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_ctor_base &
+  operator=(optional_delete_ctor_base &&) noexcept = default;
+};
+
+// optional_delete_assign_base will conditionally delete copy and move
+// constructors depending on whether T is copy/move constructible + assignable
+template <class T,
+          bool EnableCopy = (std::is_copy_constructible<T>::value &&
+                             std::is_copy_assignable<T>::value),
+          bool EnableMove = (std::is_move_constructible<T>::value &&
+                             std::is_move_assignable<T>::value)>
+struct optional_delete_assign_base {
+  __thrust_exec_check_disable__
+  optional_delete_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
+      default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(optional_delete_assign_base &&) noexcept = default;
+};
+
+template <class T> struct optional_delete_assign_base<T, true, false> {
+  __thrust_exec_check_disable__
+  optional_delete_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
+      default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(optional_delete_assign_base &&) noexcept = delete;
+};
+
+template <class T> struct optional_delete_assign_base<T, false, true> {
+  __thrust_exec_check_disable__
+  optional_delete_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
+      default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(const optional_delete_assign_base &) = delete;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(optional_delete_assign_base &&) noexcept = default;
+};
+
+template <class T> struct optional_delete_assign_base<T, false, false> {
+  __thrust_exec_check_disable__
+  optional_delete_assign_base() = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(const optional_delete_assign_base &) = default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base(optional_delete_assign_base &&) noexcept =
+      default;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(const optional_delete_assign_base &) = delete;
+  __thrust_exec_check_disable__
+  optional_delete_assign_base &
+  operator=(optional_delete_assign_base &&) noexcept = delete;
+};
+
+} // namespace detail
+
+/// \brief A tag type to represent an empty optional
+struct nullopt_t {
+  struct do_not_use {};
+  __host__ __device__
+  constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
+};
+/// \brief Represents an empty optional
+/// \synopsis static constexpr nullopt_t nullopt;
+///
+/// *Examples*:
+/// ```
+/// thrust::optional<int> a = thrust::nullopt;
+/// void foo (thrust::optional<int>);
+/// foo(thrust::nullopt); //pass an empty optional
+/// ```
+static constexpr nullopt_t nullopt{nullopt_t::do_not_use{},
+                                   nullopt_t::do_not_use{}};
+
+class bad_optional_access : public std::exception {
+public:
+  bad_optional_access() = default;
+  __host__
+  const char *what() const noexcept { return "Optional has no value"; }
+};
+
+/// An optional object is an object that contains the storage for another
+/// object and manages the lifetime of this contained object, if any. The
+/// contained object may be initialized after the optional object has been
+/// initialized, and may be destroyed before the optional object has been
+/// destroyed. The initialization state of the contained object is tracked by
+/// the optional object.
+template <class T>
+class optional : private detail::optional_move_assign_base<T>,
+                 private detail::optional_delete_ctor_base<T>,
+                 private detail::optional_delete_assign_base<T> {
+  using base = detail::optional_move_assign_base<T>;
+
+  static_assert(!std::is_same<T, in_place_t>::value,
+                "instantiation of optional with in_place_t is ill-formed");
+  static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value,
+                "instantiation of optional with nullopt_t is ill-formed");
+
+public:
+// The different versions for C++14 and 11 are needed because deduced return
+// types are not SFINAE-safe. This provides better support for things like
+// generic lambdas. C.f.
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0
+#if defined(THRUST_OPTIONAL_CPP14) && !defined(THRUST_OPTIONAL_GCC49) &&               \
+    !defined(THRUST_OPTIONAL_GCC54) && !defined(THRUST_OPTIONAL_GCC55)
+  /// \group and_then
+  /// Carries out some operation which returns an optional on the stored
+  /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+  /// value())` returns a `std::optional<U>` for some `U`. \return Let `U` be
+  /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+  /// `std::optional<U>`. The return value is empty if `*this` is empty,
+  /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+  /// is returned.
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto and_then(F &&f) & {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto and_then(F &&f) && {
+    using result = detail::invoke_result_t<F, T &&>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto and_then(F &&f) const & {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto and_then(F &&f) const && {
+    using result = detail::invoke_result_t<F, const T &&>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : result(nullopt);
+  }
+#endif
+#else
+  /// \group and_then
+  /// Carries out some operation which returns an optional on the stored
+  /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+  /// value())` returns a `std::optional<U>` for some `U`.
+  /// \return Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise the return value of
+  /// `std::invoke(std::forward<F>(f), value())` is returned.
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) & {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F &&f) && {
+    using result = detail::invoke_result_t<F, T &&>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) const && {
+    using result = detail::invoke_result_t<F, const T &&>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : result(nullopt);
+  }
+#endif
+#endif
+
+#if defined(THRUST_OPTIONAL_CPP14) && !defined(THRUST_OPTIONAL_GCC49) &&               \
+    !defined(THRUST_OPTIONAL_GCC54) && !defined(THRUST_OPTIONAL_GCC55)
+  /// \brief Carries out some operation on the stored object if there is one.
+  /// \return Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned.
+  ///
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto map(F &&f) & {
+    return optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto map(F &&f) && {
+    return optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) const&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto map(F &&f) const & {
+    return optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto map(F &&f) const && {
+    return optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+#else
+  /// \brief Carries out some operation on the stored object if there is one.
+  /// \return Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned.
+  ///
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &>(),
+                                             std::declval<F &&>()))
+  map(F &&f) & {
+    return optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR decltype(optional_map_impl(std::declval<optional &&>(),
+                                             std::declval<F &&>()))
+  map(F &&f) && {
+    return optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) const&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr decltype(optional_map_impl(std::declval<const optional &>(),
+                              std::declval<F &&>()))
+  map(F &&f) const & {
+    return optional_map_impl(*this, std::forward<F>(f));
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) const&&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
+                              std::declval<F &&>()))
+  map(F &&f) const && {
+    return optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+#endif
+#endif
+
+  /// \brief Calls `f` if the optional is empty
+  /// \requires `std::invoke_result_t<F>` must be void or convertible to
+  /// `optional<T>`.
+  /// \effects If `*this` has a value, returns `*this`.
+  /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+  /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+  ///
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) & {
+    if (has_value())
+      return *this;
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) & {
+    return has_value() ? *this : std::forward<F>(f)();
+  }
+
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) && {
+    if (has_value())
+      return std::move(*this);
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) && {
+    return has_value() ? std::move(*this) : std::forward<F>(f)();
+  }
+
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const & {
+    if (has_value())
+      return *this;
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) const & {
+    return has_value() ? *this : std::forward<F>(f)();
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const && {
+    if (has_value())
+      return std::move(*this);
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const && {
+    return has_value() ? std::move(*this) : std::forward<F>(f)();
+  }
+#endif
+
+  /// \brief Maps the stored value with `f` if there is one, otherwise returns
+  /// `u`.
+  ///
+  /// \details If there is a value stored, then `f` is called with `**this`
+  /// and the value is returned. Otherwise `u` is returned.
+  ///
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u);
+  }
+
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u);
+  }
+
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) const & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) const && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u);
+  }
+#endif
+
+  /// \brief Maps the stored value with `f` if there is one, otherwise calls
+  /// `u` and returns the result.
+  ///
+  /// \details If there is a value stored, then `f` is
+  /// called with `**this` and the value is returned. Otherwise
+  /// `std::forward<U>(u)()` is returned.
+  ///
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u)();
+  }
+
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// &&;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u)();
+  }
+
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u)();
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &&;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u)();
+  }
+#endif
+
+  /// \return `u` if `*this` has a value, otherwise an empty optional.
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const {
+    using result = optional<detail::decay_t<U>>;
+    return has_value() ? result{u} : result{nullopt};
+  }
+
+  /// \return `rhs` if `*this` is empty, otherwise the current value.
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(const optional &rhs) & {
+    return has_value() ? *this : rhs;
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(const optional &rhs) const & {
+    return has_value() ? *this : rhs;
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(const optional &rhs) && {
+    return has_value() ? std::move(*this) : rhs;
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(const optional &rhs) const && {
+    return has_value() ? std::move(*this) : rhs;
+  }
+#endif
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(optional &&rhs) & {
+    return has_value() ? *this : std::move(rhs);
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(optional &&rhs) const & {
+    return has_value() ? *this : std::move(rhs);
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(optional &&rhs) && {
+    return has_value() ? std::move(*this) : std::move(rhs);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(optional &&rhs) const && {
+    return has_value() ? std::move(*this) : std::move(rhs);
+  }
+#endif
+
+  /// Takes the value out of the optional, leaving it empty
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() & {
+    optional ret = *this;
+    reset();
+    return ret;
+  }
+
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() const & {
+    optional ret = *this;
+    reset();
+    return ret;
+  }
+
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() && {
+    optional ret = std::move(*this);
+    reset();
+    return ret;
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() const && {
+    optional ret = std::move(*this);
+    reset();
+    return ret;
+  }
+#endif
+
+  using value_type = T;
+
+  /// Constructs an optional that does not contain a value.
+  /// \group ctor_empty
+  __thrust_exec_check_disable__
+  constexpr optional() noexcept = default;
+
+  /// \group ctor_empty
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional(nullopt_t) noexcept {}
+
+  /// Copy constructor
+  ///
+  /// If `rhs` contains a value, the stored value is direct-initialized with
+  /// it. Otherwise, the constructed optional is empty.
+  __thrust_exec_check_disable__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional(const optional &rhs) = default;
+
+  /// Move constructor
+  ///
+  /// If `rhs` contains a value, the stored value is direct-initialized with
+  /// it. Otherwise, the constructed optional is empty.
+  __thrust_exec_check_disable__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional(optional &&rhs) = default;
+
+  /// Constructs the stored value in-place using the given arguments.
+  /// \group in_place
+  /// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+  __thrust_exec_check_disable__
+  template <class... Args>
+  __host__ __device__
+  constexpr explicit optional(
+      detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
+      Args &&... args)
+      : base(in_place, std::forward<Args>(args)...) {}
+
+  /// \group in_place
+  /// \synopsis template <class U, class... Args>\nconstexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+  __thrust_exec_check_disable__
+  template <class U, class... Args>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR explicit optional(
+      detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &,
+                                                Args &&...>::value,
+                          in_place_t>,
+      std::initializer_list<U> il, Args &&... args) {
+    this->construct(il, std::forward<Args>(args)...);
+  }
+
+  /// Constructs the stored value with `u`.
+  /// \synopsis template <class U=T> constexpr optional(U &&u);
+  __thrust_exec_check_disable__
+  template <
+      class U = T,
+      detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
+      detail::enable_forward_value<T, U> * = nullptr>
+  __host__ __device__
+  constexpr optional(U &&u) : base(in_place, std::forward<U>(u)) {}
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <
+      class U = T,
+      detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
+      detail::enable_forward_value<T, U> * = nullptr>
+  __host__ __device__
+  constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)) {}
+
+  /// Converting copy constructor.
+  /// \synopsis template <class U> optional(const optional<U> &rhs);
+  __thrust_exec_check_disable__
+  template <
+      class U, detail::enable_from_other<T, U, const U &> * = nullptr,
+      detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
+  __host__ __device__
+  optional(const optional<U> &rhs) {
+    this->construct(*rhs);
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class U, detail::enable_from_other<T, U, const U &> * = nullptr,
+            detail::enable_if_t<!std::is_convertible<const U &, T>::value> * =
+                nullptr>
+  __host__ __device__
+  explicit optional(const optional<U> &rhs) {
+    this->construct(*rhs);
+  }
+
+  /// Converting move constructor.
+  /// \synopsis template <class U> optional(optional<U> &&rhs);
+  __thrust_exec_check_disable__
+  template <
+      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
+      detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
+  __host__ __device__
+  optional(optional<U> &&rhs) {
+    this->construct(std::move(*rhs));
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <
+      class U, detail::enable_from_other<T, U, U &&> * = nullptr,
+      detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
+  __host__ __device__
+  explicit optional(optional<U> &&rhs) {
+    this->construct(std::move(*rhs));
+  }
+
+  /// Destroys the stored value if there is one.
+  __thrust_exec_check_disable__
+  ~optional() = default;
+
+  /// Assignment to empty.
+  ///
+  /// Destroys the current value if there is one.
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional &operator=(nullopt_t) noexcept {
+    if (has_value()) {
+      this->m_value.~T();
+      this->m_has_value = false;
+    }
+
+    return *this;
+  }
+
+  /// Copy assignment.
+  ///
+  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
+  __thrust_exec_check_disable__
+  optional &operator=(const optional &rhs) = default;
+
+  /// Move assignment.
+  ///
+  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
+  __thrust_exec_check_disable__
+  optional &operator=(optional &&rhs) = default;
+
+  /// Assigns the stored value from `u`, destroying the old value if there was
+  /// one.
+  /// \synopsis optional &operator=(U &&u);
+  __thrust_exec_check_disable__
+  template <class U = T, detail::enable_assign_forward<T, U> * = nullptr>
+  __host__ __device__
+  optional &operator=(U &&u) {
+    if (has_value()) {
+      this->m_value = std::forward<U>(u);
+    } else {
+      this->construct(std::forward<U>(u));
+    }
+
+    return *this;
+  }
+
+  /// Converting copy assignment operator.
+  ///
+  /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
+  /// \synopsis optional &operator=(const optional<U> & rhs);
+  __thrust_exec_check_disable__
+  template <class U,
+            detail::enable_assign_from_other<T, U, const U &> * = nullptr>
+  __host__ __device__
+  optional &operator=(const optional<U> &rhs) {
+    if (has_value()) {
+      if (rhs.has_value()) {
+        this->m_value = *rhs;
+      } else {
+        this->hard_reset();
+      }
+    }
+
+    if (rhs.has_value()) {
+      this->construct(*rhs);
+    }
+
+    return *this;
+  }
+
+  // TODO check exception guarantee
+  /// Converting move assignment operator.
+  ///
+  /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+  /// value in `*this`.
+  /// \synopsis optional &operator=(optional<U> && rhs);
+  __thrust_exec_check_disable__
+  template <class U, detail::enable_assign_from_other<T, U, U> * = nullptr>
+  __host__ __device__
+  optional &operator=(optional<U> &&rhs) {
+    if (has_value()) {
+      if (rhs.has_value()) {
+        this->m_value = std::move(*rhs);
+      } else {
+        this->hard_reset();
+      }
+    }
+
+    if (rhs.has_value()) {
+      this->construct(std::move(*rhs));
+    }
+
+    return *this;
+  }
+
+  /// Constructs the value in-place, destroying the current one if there is
+  /// one.
+  /// \group emplace
+  __thrust_exec_check_disable__
+  template <class... Args>
+  __host__ __device__
+  T &emplace(Args &&... args) {
+    static_assert(std::is_constructible<T, Args &&...>::value,
+                  "T must be constructible with Args");
+
+    *this = nullopt;
+    this->construct(std::forward<Args>(args)...);
+    return this->m_value;
+  }
+
+  /// \group emplace
+  /// \synopsis template <class U, class... Args>\nT& emplace(std::initializer_list<U> il, Args &&... args);
+  __thrust_exec_check_disable__
+  template <class U, class... Args>
+  __host__ __device__
+  detail::enable_if_t<
+      std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value,
+      T &>
+  emplace(std::initializer_list<U> il, Args &&... args) {
+    *this = nullopt;
+    this->construct(il, std::forward<Args>(args)...);
+    return this->m_value;
+  }
+
+  /// Swaps this optional with the other.
+  ///
+  /// If neither optionals have a value, nothing happens.
+  /// If both have a value, the values are swapped.
+  /// If one has a value, it is moved to the other and the movee is left
+  /// valueless.
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void
+  swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
+                                   &&detail::is_nothrow_swappable<T>::value) {
+    if (has_value()) {
+      if (rhs.has_value()) {
+        using thrust::swap;
+        swap(**this, *rhs);
+      } else {
+        new (addressof(rhs.m_value)) T(std::move(this->m_value));
+        this->m_value.T::~T();
+      }
+    } else if (rhs.has_value()) {
+      new (addressof(this->m_value)) T(std::move(rhs.m_value));
+      rhs.m_value.T::~T();
+    }
+  }
+
+  /// \return a pointer to the stored value
+  /// \requires a value is stored
+  /// \group pointer
+  /// \synopsis constexpr const T *operator->() const;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T *operator->() const {
+    return addressof(this->m_value);
+  }
+
+  /// \group pointer
+  /// \synopsis constexpr T *operator->();
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T *operator->() {
+    return addressof(this->m_value);
+  }
+
+  /// \return the stored value
+  /// \requires a value is stored
+  /// \group deref
+  /// \synopsis constexpr T &operator*();
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &operator*() & { return this->m_value; }
+
+  /// \group deref
+  /// \synopsis constexpr const T &operator*() const;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T &operator*() const & { return this->m_value; }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &&operator*() && {
+    return std::move(this->m_value);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \exclude
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T &&operator*() const && { return std::move(this->m_value); }
+#endif
+
+  /// \return whether or not the optional has a value
+  /// \group has_value
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool has_value() const noexcept { return this->m_has_value; }
+
+  /// \group has_value
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr explicit operator bool() const noexcept {
+    return this->m_has_value;
+  }
+
+  /// \return the contained value if there is one, otherwise throws
+  /// [bad_optional_access]
+  /// \group value
+  /// \synopsis constexpr T &value();
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &value() & {
+    if (has_value())
+      return this->m_value;
+    throw bad_optional_access();
+  }
+  /// \group value
+  /// \synopsis constexpr const T &value() const;
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR const T &value() const & {
+    if (has_value())
+      return this->m_value;
+    throw bad_optional_access();
+  }
+  /// \exclude
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &&value() && {
+    if (has_value())
+      return std::move(this->m_value);
+    throw bad_optional_access();
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \exclude
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR const T &&value() const && {
+    if (has_value())
+      return std::move(this->m_value);
+    throw bad_optional_access();
+  }
+#endif
+
+  /// \return the stored value if there is one, otherwise returns `u`
+  /// \group value_or
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  constexpr T value_or(U &&u) const & {
+    static_assert(std::is_copy_constructible<T>::value &&
+                      std::is_convertible<U &&, T>::value,
+                  "T must be copy constructible and convertible from U");
+    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+  }
+
+  /// \group value_or
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T value_or(U &&u) && {
+    static_assert(std::is_move_constructible<T>::value &&
+                      std::is_convertible<U &&, T>::value,
+                  "T must be move constructible and convertible from U");
+    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+  }
+
+  /// Destroys the stored value if one exists, making the optional empty
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void reset() noexcept {
+    if (has_value()) {
+      this->m_value.~T();
+      this->m_has_value = false;
+    }
+  }
+};
+
+/// \group relop
+/// \brief Compares two optional objects
+/// \details If both optionals contain a value, they are compared with `T`s
+/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+/// is not.
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator==(const optional<T> &lhs,
+                                 const optional<U> &rhs) {
+  return lhs.has_value() == rhs.has_value() &&
+         (!lhs.has_value() || *lhs == *rhs);
+}
+/// \group relop
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator!=(const optional<T> &lhs,
+                                 const optional<U> &rhs) {
+  return lhs.has_value() != rhs.has_value() ||
+         (lhs.has_value() && *lhs != *rhs);
+}
+/// \group relop
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<(const optional<T> &lhs,
+                                const optional<U> &rhs) {
+  return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+}
+/// \group relop
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>(const optional<T> &lhs,
+                                const optional<U> &rhs) {
+  return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+}
+/// \group relop
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<=(const optional<T> &lhs,
+                                 const optional<U> &rhs) {
+  return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+}
+/// \group relop
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>=(const optional<T> &lhs,
+                                 const optional<U> &rhs) {
+  return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+}
+
+/// \group relop_nullopt
+/// \brief Compares an optional to a `nullopt`
+/// \details Equivalent to comparing the optional to an empty optional
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator==(const optional<T> &lhs, nullopt_t) noexcept {
+  return !lhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator==(nullopt_t, const optional<T> &rhs) noexcept {
+  return !rhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator!=(const optional<T> &lhs, nullopt_t) noexcept {
+  return lhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator!=(nullopt_t, const optional<T> &rhs) noexcept {
+  return rhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator<(const optional<T> &, nullopt_t) noexcept {
+  return false;
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator<(nullopt_t, const optional<T> &rhs) noexcept {
+  return rhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator<=(const optional<T> &lhs, nullopt_t) noexcept {
+  return !lhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator<=(nullopt_t, const optional<T> &) noexcept {
+  return true;
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator>(const optional<T> &lhs, nullopt_t) noexcept {
+  return lhs.has_value();
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator>(nullopt_t, const optional<T> &) noexcept {
+  return false;
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator>=(const optional<T> &, nullopt_t) noexcept {
+  return true;
+}
+/// \group relop_nullopt
+__thrust_exec_check_disable__
+template <class T>
+__host__ __device__
+inline constexpr bool operator>=(nullopt_t, const optional<T> &rhs) noexcept {
+  return !rhs.has_value();
+}
+
+/// \group relop_t
+/// \brief Compares the optional with a value.
+/// \details If the optional has a value, it is compared with the other value
+/// using `T`s relational operators. Otherwise, the optional is considered
+/// less than the value.
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator==(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs == rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator==(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs == *rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator!=(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs != rhs : true;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator!=(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs != *rhs : true;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs < rhs : true;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs < *rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<=(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs <= rhs : true;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator<=(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs <= *rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs > rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs > *rhs : true;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>=(const optional<T> &lhs, const U &rhs) {
+  return lhs.has_value() ? *lhs >= rhs : false;
+}
+/// \group relop_t
+__thrust_exec_check_disable__
+template <class T, class U>
+__host__ __device__
+inline constexpr bool operator>=(const U &lhs, const optional<T> &rhs) {
+  return rhs.has_value() ? lhs >= *rhs : true;
+}
+
+/// \synopsis template <class T>\nvoid swap(optional<T> &lhs, optional<T> &rhs);
+__thrust_exec_check_disable__
+template <class T,
+          detail::enable_if_t<std::is_move_constructible<T>::value> * = nullptr,
+          detail::enable_if_t<detail::is_swappable<T>::value> * = nullptr>
+__host__ __device__
+void swap(optional<T> &lhs,
+          optional<T> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  return lhs.swap(rhs);
+}
+
+namespace detail {
+struct i_am_secret {};
+} // namespace detail
+
+__thrust_exec_check_disable__
+template <class T = detail::i_am_secret, class U,
+          class Ret =
+              detail::conditional_t<std::is_same<T, detail::i_am_secret>::value,
+                                    detail::decay_t<U>, T>>
+__host__ __device__
+inline constexpr optional<Ret> make_optional(U &&v) {
+  return optional<Ret>(std::forward<U>(v));
+}
+
+__thrust_exec_check_disable__
+template <class T, class... Args>
+__host__ __device__
+inline constexpr optional<T> make_optional(Args &&... args) {
+  return optional<T>(in_place, std::forward<Args>(args)...);
+}
+__thrust_exec_check_disable__
+template <class T, class U, class... Args>
+__host__ __device__
+inline constexpr optional<T> make_optional(std::initializer_list<U> il,
+                                           Args &&... args) {
+  return optional<T>(in_place, il, std::forward<Args>(args)...);
+}
+
+#if THRUST_CPP_DIALECT >= 2017
+template <class T> optional(T)->optional<T>;
+#endif
+
+// Doxygen chokes on the trailing return types used below.
+#if !defined(THRUST_DOXYGEN)
+/// \exclude
+namespace detail {
+#ifdef THRUST_OPTIONAL_CPP14
+__thrust_exec_check_disable__
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+__host__ __device__
+constexpr auto optional_map_impl(Opt &&opt, F &&f) {
+  return opt.has_value()
+             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
+             : optional<Ret>(nullopt);
+}
+
+__thrust_exec_check_disable__
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+__host__ __device__
+auto optional_map_impl(Opt &&opt, F &&f) {
+  if (opt.has_value()) {
+    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+    return make_optional(monostate{});
+  }
+
+  return optional<monostate>(nullopt);
+}
+#else
+__thrust_exec_check_disable__
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+__host__ __device__
+constexpr optional<Ret> optional_map_impl(Opt &&opt, F &&f) {
+  return opt.has_value()
+             ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt))
+             : optional<Ret>(nullopt);
+}
+
+__thrust_exec_check_disable__
+template <class Opt, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              *std::declval<Opt>())),
+          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+__host__ __device__
+auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate>
+{
+  if (opt.has_value()) {
+    detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+    return monostate{};
+  }
+
+  return nullopt;
+}
+#endif
+} // namespace detail
+#endif // !defined(THRUST_DOXYGEN)
+
+/// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+/// to a `T*`, but provides more operations and shows intent more clearly.
+///
+/// *Examples*:
+///
+/// ```
+/// int i = 42;
+/// thrust::optional<int&> o = i;
+/// *o == 42; //true
+/// i = 12;
+/// *o = 12; //true
+/// &*o == &i; //true
+/// ```
+///
+/// Assignment has rebind semantics rather than assign-through semantics:
+///
+/// ```
+/// int j = 8;
+/// o = j;
+///
+/// &*o == &j; //true
+/// ```
+template <class T> class optional<T &> {
+public:
+// The different versions for C++14 and 11 are needed because deduced return
+// types are not SFINAE-safe. This provides better support for things like
+// generic lambdas. C.f.
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0
+#if defined(THRUST_OPTIONAL_CPP14) && !defined(THRUST_OPTIONAL_GCC49) &&               \
+    !defined(THRUST_OPTIONAL_GCC54) && !defined(THRUST_OPTIONAL_GCC55)
+  /// \group and_then
+  /// Carries out some operation which returns an optional on the stored
+  /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+  /// value())` returns a `std::optional<U>` for some `U`. \return Let `U` be
+  /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+  /// `std::optional<U>`. The return value is empty if `*this` is empty,
+  /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+  /// is returned.
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto and_then(F &&f) & {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto and_then(F &&f) && {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto and_then(F &&f) const & {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto and_then(F &&f) const && {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+#endif
+#else
+  /// \group and_then
+  /// Carries out some operation which returns an optional on the stored
+  /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+  /// value())` returns a `std::optional<U>` for some `U`. \return Let `U` be
+  /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+  /// `std::optional<U>`. The return value is empty if `*this` is empty,
+  /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+  /// is returned.
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) & {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&f) && {
+    using result = detail::invoke_result_t<F, T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group and_then
+  /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const && {
+    using result = detail::invoke_result_t<F, const T &>;
+    static_assert(detail::is_optional<result>::value,
+                  "F must return an optional");
+
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : result(nullopt);
+  }
+#endif
+#endif
+
+#if defined(THRUST_OPTIONAL_CPP14) && !defined(THRUST_OPTIONAL_GCC49) &&               \
+    !defined(THRUST_OPTIONAL_GCC54) && !defined(THRUST_OPTIONAL_GCC55)
+  /// \brief Carries out some operation on the stored object if there is one.
+  /// \return Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned.
+  ///
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto map(F &&f) & {
+    return detail::optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR auto map(F &&f) && {
+    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) const&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto map(F &&f) const & {
+    return detail::optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr auto map(F &&f) const && {
+    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+#else
+  /// \brief Carries out some operation on the stored object if there is one.
+  /// \return Let `U` be the result of `std::invoke(std::forward<F>(f),
+  /// value())`. Returns a `std::optional<U>`. The return value is empty if
+  /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+  /// return value of `std::invoke(std::forward<F>(f), value())` and is
+  /// returned.
+  ///
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &>(),
+                                                     std::declval<F &&>()))
+  map(F &&f) & {
+    return detail::optional_map_impl(*this, std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional &&>(),
+                                                     std::declval<F &&>()))
+  map(F &&f) && {
+    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) const&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr decltype(detail::optional_map_impl(std::declval<const optional &>(),
+                                      std::declval<F &&>()))
+  map(F &&f) const & {
+    return detail::optional_map_impl(*this, std::forward<F>(f));
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map
+  /// \synopsis template <class F> auto map(F &&f) const&&;
+  __thrust_exec_check_disable__
+  template <class F>
+  __host__ __device__
+  constexpr decltype(detail::optional_map_impl(std::declval<const optional &&>(),
+                                      std::declval<F &&>()))
+  map(F &&f) const && {
+    return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+  }
+#endif
+#endif
+
+  /// \brief Calls `f` if the optional is empty
+  /// \requires `std::invoke_result_t<F>` must be void or convertible to
+  /// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+  /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+  /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+  ///
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) &;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T>
+  THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) & {
+    if (has_value())
+      return *this;
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T>
+  THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) & {
+    return has_value() ? *this : std::forward<F>(f)();
+  }
+
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) && {
+    if (has_value())
+      return std::move(*this);
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) && {
+    return has_value() ? std::move(*this) : std::forward<F>(f)();
+  }
+
+  /// \group or_else
+  /// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const & {
+    if (has_value())
+      return *this;
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> THRUST_OPTIONAL_CPP11_CONSTEXPR or_else(F &&f) const & {
+    return has_value() ? *this : std::forward<F>(f)();
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::enable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const && {
+    if (has_value())
+      return std::move(*this);
+
+    std::forward<F>(f)();
+    return nullopt;
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class F, detail::disable_if_ret_void<F> * = nullptr>
+  __host__ __device__
+  optional<T> or_else(F &&f) const && {
+    return has_value() ? std::move(*this) : std::forward<F>(f)();
+  }
+#endif
+
+  /// \brief Maps the stored value with `f` if there is one, otherwise returns
+  /// `u`.
+  ///
+  /// \details If there is a value stored, then `f` is called with `**this`
+  /// and the value is returned. Otherwise `u` is returned.
+  ///
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u);
+  }
+
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u);
+  }
+
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) const & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map_or
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  U map_or(F &&f, U &&u) const && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u);
+  }
+#endif
+
+  /// \brief Maps the stored value with `f` if there is one, otherwise calls
+  /// `u` and returns the result.
+  ///
+  /// \details If there is a value stored, then `f` is
+  /// called with `**this` and the value is returned. Otherwise
+  /// `std::forward<U>(u)()` is returned.
+  ///
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u)();
+  }
+
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// &&;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u)();
+  }
+
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
+    return has_value() ? detail::invoke(std::forward<F>(f), **this)
+                       : std::forward<U>(u)();
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group map_or_else
+  /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+  /// const &&;
+  __thrust_exec_check_disable__
+  template <class F, class U>
+  __host__ __device__
+  detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
+    return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this))
+                       : std::forward<U>(u)();
+  }
+#endif
+
+  /// \return `u` if `*this` has a value, otherwise an empty optional.
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  constexpr optional<typename std::decay<U>::type> conjunction(U &&u) const {
+    using result = optional<detail::decay_t<U>>;
+    return has_value() ? result{u} : result{nullopt};
+  }
+
+  /// \return `rhs` if `*this` is empty, otherwise the current value.
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(const optional &rhs) & {
+    return has_value() ? *this : rhs;
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(const optional &rhs) const & {
+    return has_value() ? *this : rhs;
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(const optional &rhs) && {
+    return has_value() ? std::move(*this) : rhs;
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(const optional &rhs) const && {
+    return has_value() ? std::move(*this) : rhs;
+  }
+#endif
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(optional &&rhs) & {
+    return has_value() ? *this : std::move(rhs);
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(optional &&rhs) const & {
+    return has_value() ? *this : std::move(rhs);
+  }
+
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional disjunction(optional &&rhs) && {
+    return has_value() ? std::move(*this) : std::move(rhs);
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group disjunction
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional disjunction(optional &&rhs) const && {
+    return has_value() ? std::move(*this) : std::move(rhs);
+  }
+#endif
+
+  /// Takes the value out of the optional, leaving it empty
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() & {
+    optional ret = *this;
+    reset();
+    return ret;
+  }
+
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() const & {
+    optional ret = *this;
+    reset();
+    return ret;
+  }
+
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() && {
+    optional ret = std::move(*this);
+    reset();
+    return ret;
+  }
+
+#ifndef THRUST_OPTIONAL_NO_CONSTRR
+  /// \group take
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional take() const && {
+    optional ret = std::move(*this);
+    reset();
+    return ret;
+  }
+#endif
+
+  using value_type = T &;
+
+  /// Constructs an optional that does not contain a value.
+  /// \group ctor_empty
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional() noexcept : m_value(nullptr) {}
+
+  /// \group ctor_empty
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr optional(nullopt_t) noexcept : m_value(nullptr) {}
+
+  /// Copy constructor
+  ///
+  /// If `rhs` contains a value, the stored value is direct-initialized with
+  /// it. Otherwise, the constructed optional is empty.
+  __thrust_exec_check_disable__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional(const optional &rhs) noexcept = default;
+
+  /// Move constructor
+  ///
+  /// If `rhs` contains a value, the stored value is direct-initialized with
+  /// it. Otherwise, the constructed optional is empty.
+  __thrust_exec_check_disable__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR optional(optional &&rhs) = default;
+
+  /// Constructs the stored value with `u`.
+  /// \synopsis template <class U=T> constexpr optional(U &&u);
+  __thrust_exec_check_disable__
+  template <class U = T,
+            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
+                * = nullptr>
+  __host__ __device__
+  constexpr optional(U &&u) : m_value(addressof(u)) {
+    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+  }
+
+  /// \exclude
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  constexpr explicit optional(const optional<U> &rhs) : optional(*rhs) {}
+
+  /// No-op
+  __thrust_exec_check_disable__
+  ~optional() = default;
+
+  /// Assignment to empty.
+  ///
+  /// Destroys the current value if there is one.
+  __thrust_exec_check_disable__
+  __host__ __device__
+  optional &operator=(nullopt_t) noexcept {
+    m_value = nullptr;
+    return *this;
+  }
+
+  /// Copy assignment.
+  ///
+  /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+  /// resets the stored value in `*this`.
+  __thrust_exec_check_disable__
+  optional &operator=(const optional &rhs) = default;
+
+  /// Rebinds this optional to `u`.
+  ///
+  /// \requires `U` must be an lvalue reference.
+  /// \synopsis optional &operator=(U &&u);
+  __thrust_exec_check_disable__
+  template <class U = T,
+            detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>
+                * = nullptr>
+  __host__ __device__
+  optional &operator=(U &&u) {
+    static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+    m_value = addressof(u);
+    return *this;
+  }
+
+  /// Converting copy assignment operator.
+  ///
+  /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+  /// resets the stored value in `*this`.
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  optional &operator=(const optional<U> &rhs) {
+    m_value = addressof(rhs.value());
+    return *this;
+  }
+
+  /// Constructs the value in-place, destroying the current one if there is
+  /// one.
+  ///
+  /// \group emplace
+  __thrust_exec_check_disable__
+  template <class... Args>
+  __host__ __device__
+  T &emplace(Args &&... args) noexcept {
+    static_assert(std::is_constructible<T, Args &&...>::value,
+                  "T must be constructible with Args");
+
+    *this = nullopt;
+    this->construct(std::forward<Args>(args)...);
+  }
+
+  /// Swaps this optional with the other.
+  ///
+  /// If neither optionals have a value, nothing happens.
+  /// If both have a value, the values are swapped.
+  /// If one has a value, it is moved to the other and the movee is left
+  /// valueless.
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
+
+  /// \return a pointer to the stored value
+  /// \requires a value is stored
+  /// \group pointer
+  /// \synopsis constexpr const T *operator->() const;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T *operator->() const { return m_value; }
+
+  /// \group pointer
+  /// \synopsis constexpr T *operator->();
+  __thrust_exec_check_disable__
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T *operator->() { return m_value; }
+
+  /// \return the stored value
+  /// \requires a value is stored
+  /// \group deref
+  /// \synopsis constexpr T &operator*();
+  __thrust_exec_check_disable__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &operator*() { return *m_value; }
+
+  /// \group deref
+  /// \synopsis constexpr const T &operator*() const;
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr const T &operator*() const { return *m_value; }
+
+  /// \return whether or not the optional has a value
+  /// \group has_value
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr bool has_value() const noexcept { return m_value != nullptr; }
+
+  /// \group has_value
+  __thrust_exec_check_disable__
+  __host__ __device__
+  constexpr explicit operator bool() const noexcept {
+    return m_value != nullptr;
+  }
+
+  /// \return the contained value if there is one, otherwise throws
+  /// [bad_optional_access]
+  /// \group value
+  /// synopsis constexpr T &value();
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T &value() {
+    if (has_value())
+      return *m_value;
+    throw bad_optional_access();
+  }
+  /// \group value
+  /// \synopsis constexpr const T &value() const;
+  __host__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR const T &value() const {
+    if (has_value())
+      return *m_value;
+    throw bad_optional_access();
+  }
+
+  /// \return the stored value if there is one, otherwise returns `u`
+  /// \group value_or
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  constexpr T value_or(U &&u) const & {
+    static_assert(std::is_copy_constructible<T>::value &&
+                      std::is_convertible<U &&, T>::value,
+                  "T must be copy constructible and convertible from U");
+    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+  }
+
+  /// \group value_or
+  __thrust_exec_check_disable__
+  template <class U>
+  __host__ __device__
+  THRUST_OPTIONAL_CPP11_CONSTEXPR T value_or(U &&u) && {
+    static_assert(std::is_move_constructible<T>::value &&
+                      std::is_convertible<U &&, T>::value,
+                  "T must be move constructible and convertible from U");
+    return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+  }
+
+  /// Destroys the stored value if one exists, making the optional empty
+  __thrust_exec_check_disable__
+  void reset() noexcept { m_value = nullptr; }
+
+private:
+  T *m_value;
+};
+
+THRUST_NAMESPACE_END
+
+namespace std {
+// TODO SFINAE
+template <class T> struct hash<THRUST_NS_QUALIFIER::optional<T>> {
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ::std::size_t operator()(const THRUST_NS_QUALIFIER::optional<T> &o) const {
+    if (!o.has_value())
+      return 0;
+
+    return std::hash<THRUST_NS_QUALIFIER::detail::remove_const_t<T>>()(*o);
+  }
+};
+} // namespace std
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/pair.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/pair.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb2138aaf2ca348c108aaeb9c423cc70b2fe0faf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/pair.h
@@ -0,0 +1,281 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file pair.h
+ *  \brief A type encapsulating a heterogeneous pair of elements
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup pair
+ *  \{
+ */
+
+/*! \p pair is a generic data structure encapsulating a heterogeneous
+ *  pair of values.
+ *
+ *  \tparam T1 The type of \p pair's first object type.  There are no
+ *          requirements on the type of \p T1. <tt>T1</tt>'s type is
+ *          provided by <tt>pair::first_type</tt>.
+ *
+ *  \tparam T2 The type of \p pair's second object type.  There are no
+ *          requirements on the type of \p T2. <tt>T2</tt>'s type is
+ *          provided by <tt>pair::second_type</tt>.
+ */
+template <typename T1, typename T2>
+  struct pair
+{
+  /*! \p first_type is the type of \p pair's first object type.
+   */
+  typedef T1 first_type;
+
+  /*! \p second_type is the type of \p pair's second object type.
+   */
+  typedef T2 second_type;
+
+  /*! The \p pair's first object.
+   */
+  first_type first;
+
+  /*! The \p pair's second object.
+   */
+  second_type second;
+
+  /*! \p pair's default constructor constructs \p first
+   *  and \p second using \c first_type & \c second_type's
+   *  default constructors, respectively.
+   */
+  __host__ __device__ pair(void);
+
+  /*! This constructor accepts two objects to copy into this \p pair.
+   *
+   *  \param x The object to copy into \p first.
+   *  \param y The object to copy into \p second.
+   */
+  inline __host__ __device__
+  pair(const T1 &x, const T2 &y);
+
+  /*! This copy constructor copies from a \p pair whose types are
+   *  convertible to this \p pair's \c first_type and \c second_type,
+   *  respectively.
+   *
+   *  \param p The \p pair to copy from.
+   *
+   *  \tparam U1 is convertible to \c first_type.
+   *  \tparam U2 is convertible to \c second_type.
+   */
+  template <typename U1, typename U2>
+  inline __host__ __device__
+  pair(const pair<U1,U2> &p);
+
+  /*! This copy constructor copies from a <tt>std::pair</tt> whose types are
+   *  convertible to this \p pair's \c first_type and \c second_type,
+   *  respectively.
+   *
+   *  \param p The <tt>std::pair</tt> to copy from.
+   *
+   *  \tparam U1 is convertible to \c first_type.
+   *  \tparam U2 is convertible to \c second_type.
+   */
+  template <typename U1, typename U2>
+  inline __host__ __device__
+  pair(const std::pair<U1,U2> &p);
+
+  /*! \p swap swaps the elements of two <tt>pair</tt>s.
+   *  
+   *  \param p The other <tt>pair</tt> with which to swap.
+   */
+  inline __host__ __device__
+  void swap(pair &p);
+}; // end pair
+
+
+/*! This operator tests two \p pairs for equality.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>x.first == y.first && x.second == y.second</tt>.
+ *  
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator==(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! This operator tests two pairs for ascending ordering.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>x.first < y.first || (!(y.first < x.first) && x.second < y.second)</tt>.
+ *
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator<(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! This operator tests two pairs for inequality.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>!(x == y)</tt>.
+ *
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator!=(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! This operator tests two pairs for descending ordering.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>y < x</tt>.
+ *
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator>(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! This operator tests two pairs for ascending ordering or equivalence.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>!(y < x)</tt>.
+ *
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator<=(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! This operator tests two pairs for descending ordering or equivalence.
+ *
+ *  \param x The first \p pair to compare.
+ *  \param y The second \p pair to compare.
+ *  \return \c true if and only if <tt>!(x < y)</tt>.
+ *
+ *  \tparam T1 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *  \tparam T2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    bool operator>=(const pair<T1,T2> &x, const pair<T1,T2> &y);
+
+
+/*! \p swap swaps the contents of two <tt>pair</tt>s.
+ *
+ *  \param x The first \p pair to swap.
+ *  \param y The second \p pair to swap.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    void swap(pair<T1,T2> &x, pair<T1,T2> &y);
+
+
+/*! This convenience function creates a \p pair from two objects.
+ *
+ *  \param x The first object to copy from.
+ *  \param y The second object to copy from.
+ *  \return A newly-constructed \p pair copied from \p a and \p b.
+ *
+ *  \tparam T1 There are no requirements on the type of \p T1.
+ *  \tparam T2 There are no requirements on the type of \p T2.
+ */
+template <typename T1, typename T2>
+  inline __host__ __device__
+    pair<T1,T2> make_pair(T1 x, T2 y);
+
+
+/*! This convenience metafunction is included for compatibility with
+ *  \p tuple. It returns either the type of a \p pair's
+ *  \c first_type or \c second_type in its nested type, \c type.
+ *
+ *  \tparam N This parameter selects the member of interest.
+ *  \tparam T A \c pair type of interest.
+ */
+template<size_t N, class T> struct tuple_element;
+
+
+/*! This convenience metafunction is included for compatibility with
+ *  \p tuple. It returns \c 2, the number of elements of a \p pair,
+ *  in its nested data member, \c value.
+ *
+ *  \tparam Pair A \c pair type of interest.
+ */
+template<typename Pair> struct tuple_size;
+
+
+/*! This convenience function returns a reference to either the first or
+ *  second member of a \p pair.
+ *
+ *  \param p The \p pair of interest.
+ *  \return \c p.first or \c p.second, depending on the template
+ *          parameter.
+ *
+ *  \tparam N This parameter selects the member of interest.
+ */
+// XXX comment out these prototypes as a WAR to a problem on MSVC 2005
+//template<unsigned int N, typename T1, typename T2>
+//  inline __host__ __device__
+//    typename tuple_element<N, pair<T1,T2> >::type &
+//      get(pair<T1,T2> &p);
+
+
+/*! This convenience function returns a const reference to either the
+ *  first or second member of a \p pair.
+ *
+ *  \param p The \p pair of interest.
+ *  \return \c p.first or \c p.second, depending on the template
+ *          parameter.
+ *
+ *  \tparam i This parameter selects the member of interest.
+ */
+// XXX comment out these prototypes as a WAR to a problem on MSVC 2005
+//template<int N, typename T1, typename T2>
+//  inline __host__ __device__
+//    const typename tuple_element<N, pair<T1,T2> >::type &
+//      get(const pair<T1,T2> &p);
+
+/*! \} // pair
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/pair.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/partition.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/partition.h
new file mode 100644
index 0000000000000000000000000000000000000000..90768f2467668726fc5fd86d974d19bb07bfa125
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/partition.h
@@ -0,0 +1,1436 @@
+/*
+ *  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 partition.h
+ *  \brief Reorganizes a range based on a predicate
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reordering
+ *  \ingroup algorithms
+ *
+ *  \addtogroup partitioning
+ *  \ingroup reordering
+ *  \{
+ */
+
+
+/*! \p partition reorders the elements <tt>[first, last)</tt> based on the function
+ *  object \p pred, such that all of the elements that satisfy \p pred precede the
+ *  elements that fail to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*i)</tt> is \c true for every
+ *  iterator \c i in the range <tt>[first,middle)</tt> and \c false for every iterator
+ *  \c i in the range <tt>[middle, last)</tt>. The return value of \p partition is
+ *  \c middle.
+ *
+ *  Note that the relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition, does guarantee to preserve the relative order.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements which do not satisfy \p pred.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p partition to reorder a
+ *  sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::partition(thrust::host,
+ *                    A, A + N,
+ *                    is_even());
+ *  // A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partition
+ *  \see \p stable_partition
+ *  \see \p partition_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+/*! \p partition reorders the elements <tt>[first, last)</tt> based on the function
+ *  object \p pred, such that all of the elements that satisfy \p pred precede the
+ *  elements that fail to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*i)</tt> is \c true for every
+ *  iterator \c i in the range <tt>[first,middle)</tt> and \c false for every iterator
+ *  \c i in the range <tt>[middle, last)</tt>. The return value of \p partition is
+ *  \c middle.
+ *
+ *  Note that the relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition, does guarantee to preserve the relative order.
+ *
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements which do not satisfy \p pred.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p partition to reorder a
+ *  sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::partition(A, A + N,
+ *                     is_even());
+ *  // A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partition
+ *  \see \p stable_partition
+ *  \see \p partition_copy
+ */
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator partition(ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+/*! \p partition reorders the elements <tt>[first, last)</tt> based on the function
+ *  object \p pred applied to a stencil range <tt>[stencil, stencil + (last - first))</tt>,
+ *  such that all of the elements whose corresponding stencil element satisfies \p pred precede all of the elements whose
+ *  corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*stencil_i)</tt> is \c true for every iterator
+ *  \c stencil_i in the range <tt>[stencil,stencil + (middle - first))</tt> and \c false for every iterator \c stencil_i
+ *  in the range <tt>[stencil + (middle - first), stencil + (last - first))</tt>.
+ *  The return value of \p stable_partition is \c middle.
+ *
+ *  Note that the relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition, does guarantee to preserve the relative order.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements whose stencil elements do not satisfy \p pred.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[stencil, stencil + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p partition to reorder a
+ *  sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::partition(thrust::host, A, A + N, S, is_even());
+ *  // A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  // S is unmodified
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partition
+ *  \see \p stable_partition
+ *  \see \p partition_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+/*! \p partition reorders the elements <tt>[first, last)</tt> based on the function
+ *  object \p pred applied to a stencil range <tt>[stencil, stencil + (last - first))</tt>,
+ *  such that all of the elements whose corresponding stencil element satisfies \p pred precede all of the elements whose
+ *  corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*stencil_i)</tt> is \c true for every iterator
+ *  \c stencil_i in the range <tt>[stencil,stencil + (middle - first))</tt> and \c false for every iterator \c stencil_i
+ *  in the range <tt>[stencil + (middle - first), stencil + (last - first))</tt>.
+ *  The return value of \p stable_partition is \c middle.
+ *
+ *  Note that the relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition, does guarantee to preserve the relative order.
+ *
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements whose stencil elements do not satisfy \p pred.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first,last)</tt> and <tt>[stencil, stencil + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p partition to reorder a
+ *  sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::partition(A, A + N, S, is_even());
+ *  // A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  // S is unmodified
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partition
+ *  \see \p stable_partition
+ *  \see \p partition_copy
+ */
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator partition(ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+/*! \p partition_copy differs from \p partition only in that the reordered
+ *  sequence is written to difference output sequences, rather than in place.
+ *
+ *  \p partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred. All of the elements that satisfy \p pred are copied
+ *  to the range beginning at \p out_true and all the elements that fail to satisfy it
+ *  are copied to the range beginning at \p out_false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type and \p InputIterator's \c value_type
+ *          is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input range shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p partition_copy to separate a
+ *  sequence into two output sequences of even and odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::partition_copy(thrust::host, A, A + N, evens, odds, is_even());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \note The relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition_copy, does guarantee to preserve the relative order.
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p stable_partition_copy
+ *  \see \p partition
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+/*! \p partition_copy differs from \p partition only in that the reordered
+ *  sequence is written to difference output sequences, rather than in place.
+ *
+ *  \p partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred. All of the elements that satisfy \p pred are copied
+ *  to the range beginning at \p out_true and all the elements that fail to satisfy it
+ *  are copied to the range beginning at \p out_false.
+ *
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type and \p InputIterator's \c value_type
+ *          is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input range shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p partition_copy to separate a
+ *  sequence into two output sequences of even and odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::partition_copy(A, A + N, evens, odds, is_even());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \note The relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition_copy, does guarantee to preserve the relative order.
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p stable_partition_copy
+ *  \see \p partition
+ */
+template<typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(InputIterator first,
+                   InputIterator last,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+/*! \p partition_copy differs from \p partition only in that the reordered
+ *  sequence is written to difference output sequences, rather than in place.
+ *
+ *  \p partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred which is applied to a range of stencil elements. All of the elements
+ *  whose corresponding stencil element satisfies \p pred are copied to the range beginning at \p out_true
+ *  and all the elements whose stencil element fails to satisfy it are copied to the range beginning
+ *  at \p out_false.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p partition_copy to separate a
+ *  sequence into two output sequences of even and odd numbers using the \p thrust::host execution
+ *  policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(thrust::host, A, A + N, S, evens, odds, thrust::identity<int>());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \note The relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition_copy, does guarantee to preserve the relative order.
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p stable_partition_copy
+ *  \see \p partition
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   InputIterator1 first,
+                   InputIterator1 last,
+                   InputIterator2 stencil,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+/*! \p partition_copy differs from \p partition only in that the reordered
+ *  sequence is written to difference output sequences, rather than in place.
+ *
+ *  \p partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred which is applied to a range of stencil elements. All of the elements
+ *  whose corresponding stencil element satisfies \p pred are copied to the range beginning at \p out_true
+ *  and all the elements whose stencil element fails to satisfy it are copied to the range beginning
+ *  at \p out_false.
+ *
+ *  \param first The beginning of the sequence to reorder.
+ *  \param last The end of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p partition_copy to separate a
+ *  sequence into two output sequences of even and odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(A, A + N, S, evens, odds, thrust::identity<int>());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \note The relative order of elements in the two reordered sequences is not
+ *  necessarily the same as it was in the original sequence. A different algorithm,
+ *  \p stable_partition_copy, does guarantee to preserve the relative order.
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p stable_partition_copy
+ *  \see \p partition
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(InputIterator1 first,
+                   InputIterator1 last,
+                   InputIterator2 stencil,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+/*! \p stable_partition is much like \p partition : it reorders the elements in the
+ *  range <tt>[first, last)</tt> based on the function object \p pred, such that all of
+ *  the elements that satisfy \p pred precede all of the elements that fail to satisfy
+ *  it. The postcondition is that, for some iterator \p middle in the range
+ *  <tt>[first, last)</tt>, <tt>pred(*i)</tt> is \c true for every iterator \c i in the
+ *  range <tt>[first,middle)</tt> and \c false for every iterator \c i in the range
+ *  <tt>[middle, last)</tt>. The return value of \p stable_partition is \c middle.
+ *
+ *  \p stable_partition differs from \p partition in that \p stable_partition is
+ *  guaranteed to preserve relative order. That is, if \c x and \c y are elements in
+ *  <tt>[first, last)</tt>, and \c stencil_x and \c stencil_y are the stencil elements
+ *  in corresponding positions within <tt>[stencil, stencil + (last - first))</tt>,
+ *  and <tt>pred(stencil_x) == pred(stencil_y)</tt>, and if \c x precedes
+ *  \c y, then it will still be true after \p stable_partition that \c x precedes \c y.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements which do not satisfy pred.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition to reorder a
+ *  sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::stable_partition(thrust::host,
+ *                           A, A + N,
+ *                           is_even());
+ *  // A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_partition
+ *  \see \p partition
+ *  \see \p stable_partition_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred);
+
+
+/*! \p stable_partition is much like \p partition : it reorders the elements in the
+ *  range <tt>[first, last)</tt> based on the function object \p pred, such that all of
+ *  the elements that satisfy \p pred precede all of the elements that fail to satisfy
+ *  it. The postcondition is that, for some iterator \p middle in the range
+ *  <tt>[first, last)</tt>, <tt>pred(*i)</tt> is \c true for every iterator \c i in the
+ *  range <tt>[first,middle)</tt> and \c false for every iterator \c i in the range
+ *  <tt>[middle, last)</tt>. The return value of \p stable_partition is \c middle.
+ *
+ *  \p stable_partition differs from \p partition in that \p stable_partition is
+ *  guaranteed to preserve relative order. That is, if \c x and \c y are elements in
+ *  <tt>[first, last)</tt>, and \c stencil_x and \c stencil_y are the stencil elements
+ *  in corresponding positions within <tt>[stencil, stencil + (last - first))</tt>,
+ *  and <tt>pred(stencil_x) == pred(stencil_y)</tt>, and if \c x precedes
+ *  \c y, then it will still be true after \p stable_partition that \c x precedes \c y.
+ *
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements which do not satisfy pred.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition to reorder a
+ *  sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::stable_partition(A, A + N,
+ *                            is_even());
+ *  // A is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_partition
+ *  \see \p partition
+ *  \see \p stable_partition_copy
+ */
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred);
+
+
+/*! \p stable_partition is much like \p partition: it reorders the elements in the
+ *  range <tt>[first, last)</tt> based on the function object \p pred applied to a stencil
+ *  range <tt>[stencil, stencil + (last - first))</tt>, such that all of
+ *  the elements whose corresponding stencil element satisfies \p pred precede all of the elements whose
+ *  corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*stencil_i)</tt> is \c true for every iterator
+ *  \c stencil_i in the range <tt>[stencil,stencil + (middle - first))</tt> and \c false for every iterator \c stencil_i
+ *  in the range <tt>[stencil + (middle - first), stencil + (last - first))</tt>.
+ *  The return value of \p stable_partition is \c middle.
+ *
+ *  \p stable_partition differs from \p partition in that \p stable_partition is
+ *  guaranteed to preserve relative order. That is, if \c x and \c y are elements in
+ *  <tt>[first, last)</tt>, such that <tt>pred(x) == pred(y)</tt>, and if \c x precedes
+ *  \c y, then it will still be true after \p stable_partition that \c x precedes \c y.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements whose stencil elements do not satisfy \p pred.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap with the range <tt>[stencil, stencil + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition to reorder a
+ *  sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::stable_partition(thrust::host, A, A + N, S, is_even());
+ *  // A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  // S is unmodified
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_partition
+ *  \see \p partition
+ *  \see \p stable_partition_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred);
+
+
+/*! \p stable_partition is much like \p partition: it reorders the elements in the
+ *  range <tt>[first, last)</tt> based on the function object \p pred applied to a stencil
+ *  range <tt>[stencil, stencil + (last - first))</tt>, such that all of
+ *  the elements whose corresponding stencil element satisfies \p pred precede all of the elements whose
+ *  corresponding stencil element fails to satisfy it. The postcondition is that, for some iterator
+ *  \c middle in the range <tt>[first, last)</tt>, <tt>pred(*stencil_i)</tt> is \c true for every iterator
+ *  \c stencil_i in the range <tt>[stencil,stencil + (middle - first))</tt> and \c false for every iterator \c stencil_i
+ *  in the range <tt>[stencil + (middle - first), stencil + (last - first))</tt>.
+ *  The return value of \p stable_partition is \c middle.
+ *
+ *  \p stable_partition differs from \p partition in that \p stable_partition is
+ *  guaranteed to preserve relative order. That is, if \c x and \c y are elements in
+ *  <tt>[first, last)</tt>, such that <tt>pred(x) == pred(y)</tt>, and if \c x precedes
+ *  \c y, then it will still be true after \p stable_partition that \c x precedes \c y.
+ *
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return An iterator referring to the first element of the second partition, that is,
+ *          the sequence of the elements whose stencil elements do not satisfy \p pred.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap with the range <tt>[stencil, stencil + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition to reorder a
+ *  sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int S[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::stable_partition(A, A + N, S, is_even());
+ *  // A is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  // S is unmodified
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_partition
+ *  \see \p partition
+ *  \see \p stable_partition_copy
+ */
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred);
+
+
+/*! \p stable_partition_copy differs from \p stable_partition only in that the reordered
+ *  sequence is written to different output sequences, rather than in place.
+ *
+ *  \p stable_partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred. All of the elements that satisfy \p pred are copied
+ *  to the range beginning at \p out_true and all the elements that fail to satisfy it
+ *  are copied to the range beginning at \p out_false.
+ *
+ *  \p stable_partition_copy differs from \p partition_copy in that
+ *  \p stable_partition_copy is guaranteed to preserve relative order. That is, if
+ *  \c x and \c y are elements in <tt>[first, last)</tt>, such that
+ *  <tt>pred(x) == pred(y)</tt>, and if \c x precedes \c y, then it will still be true
+ *  after \p stable_partition_copy that \c x precedes \c y in the output.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type and \p InputIterator's \c value_type
+ *          is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition_copy to
+ *  reorder a sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(thrust::host, A, A + N, evens, odds, is_even());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p partition_copy
+ *  \see \p stable_partition
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+/*! \p stable_partition_copy differs from \p stable_partition only in that the reordered
+ *  sequence is written to different output sequences, rather than in place.
+ *
+ *  \p stable_partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred. All of the elements that satisfy \p pred are copied
+ *  to the range beginning at \p out_true and all the elements that fail to satisfy it
+ *  are copied to the range beginning at \p out_false.
+ *
+ *  \p stable_partition_copy differs from \p partition_copy in that
+ *  \p stable_partition_copy is guaranteed to preserve relative order. That is, if
+ *  \c x and \c y are elements in <tt>[first, last)</tt>, such that
+ *  <tt>pred(x) == pred(y)</tt>, and if \c x precedes \c y, then it will still be true
+ *  after \p stable_partition_copy that \c x precedes \c y in the output.
+ *
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type and \p InputIterator's \c value_type
+ *          is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition_copy to
+ *  reorder a sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(A, A + N, evens, odds, is_even());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p partition_copy
+ *  \see \p stable_partition
+ */
+template<typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+/*! \p stable_partition_copy differs from \p stable_partition only in that the reordered
+ *  sequence is written to different output sequences, rather than in place.
+ *
+ *  \p stable_partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred which is applied to a range of stencil elements. All of the elements
+ *  whose corresponding stencil element satisfies \p pred are copied to the range beginning at \p out_true
+ *  and all the elements whose stencil element fails to satisfy it are copied to the range beginning
+ *  at \p out_false.
+ *
+ *  \p stable_partition_copy differs from \p partition_copy in that
+ *  \p stable_partition_copy is guaranteed to preserve relative order. That is, if
+ *  \c x and \c y are elements in <tt>[first, last)</tt>, such that
+ *  <tt>pred(x) == pred(y)</tt>, and if \c x precedes \c y, then it will still be true
+ *  after \p stable_partition_copy that \c x precedes \c y in the output.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition_copy to
+ *  reorder a sequence so that even numbers precede odd numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(thrust::host, A, A + N, S, evens, odds, thrust::identity<int>());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p partition_copy
+ *  \see \p stable_partition
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+/*! \p stable_partition_copy differs from \p stable_partition only in that the reordered
+ *  sequence is written to different output sequences, rather than in place.
+ *
+ *  \p stable_partition_copy copies the elements <tt>[first, last)</tt> based on the
+ *  function object \p pred which is applied to a range of stencil elements. All of the elements
+ *  whose corresponding stencil element satisfies \p pred are copied to the range beginning at \p out_true
+ *  and all the elements whose stencil element fails to satisfy it are copied to the range beginning
+ *  at \p out_false.
+ *
+ *  \p stable_partition_copy differs from \p partition_copy in that
+ *  \p stable_partition_copy is guaranteed to preserve relative order. That is, if
+ *  \c x and \c y are elements in <tt>[first, last)</tt>, such that
+ *  <tt>pred(x) == pred(y)</tt>, and if \c x precedes \c y, then it will still be true
+ *  after \p stable_partition_copy that \c x precedes \c y in the output.
+ *
+ *  \param first The first element of the sequence to reorder.
+ *  \param last One position past the last element of the sequence to reorder.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param out_true The destination of the resulting sequence of elements which satisfy \p pred.
+ *  \param out_false The destination of the resulting sequence of elements which fail to satisfy \p pred.
+ *  \param pred A function object which decides to which partition each element of the
+ *              sequence <tt>[first, last)</tt> belongs.
+ *  \return A \p pair p such that <tt>p.first</tt> is the end of the output range beginning
+ *          at \p out_true and <tt>p.second</tt> is the end of the output range beginning at
+ *          \p out_false.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p OutputIterator1 and \p OutputIterator2's \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap with either output range.
+ *
+ *  The following code snippet demonstrates how to use \p stable_partition_copy to
+ *  reorder a sequence so that even numbers precede odd numbers.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int S[] = {0, 1, 0, 1, 0, 1, 0, 1, 0,  1};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  int *evens = result;
+ *  int *odds  = result + 5;
+ *  thrust::stable_partition_copy(A, A + N, S, evens, odds, thrust::identity<int>());
+ *  // A remains {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  // S remains {0, 1, 0, 1, 0, 1, 0, 1, 0,  1}
+ *  // result is now {2, 4, 6, 8, 10, 1, 3, 5, 7, 9}
+ *  // evens points to {2, 4, 6, 8, 10}
+ *  // odds points to {1, 3, 5, 7, 9}
+ *  \endcode
+ *
+ *  \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2569.pdf
+ *  \see \p partition_copy
+ *  \see \p stable_partition
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+/*! \} // end stream_compaction
+ */
+
+/*! \} // end reordering
+ */
+
+/*! \addtogroup searching
+ *  \{
+ */
+
+
+/*! \p partition_point returns an iterator pointing to the end of the true
+ *  partition of a partitioned range. \p partition_point requires the input range
+ *  <tt>[first,last)</tt> to be a partition; that is, all elements which satisfy
+ *  <tt>pred</tt> shall appear before those that do not.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to consider.
+ *  \param last The end of the range to consider.
+ *  \param pred A function object which decides to which partition each element of the
+ *              range <tt>[first, last)</tt> belongs.
+ *  \return An iterator \c mid such that <tt>all_of(first, mid, pred)</tt>
+ *          and <tt>none_of(mid, last, pred)</tt> are both true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall be partitioned by \p pred.
+ *
+ *  \note Though similar, \p partition_point is not redundant with \p find_if_not.
+ *        \p partition_point's precondition provides an opportunity for a
+ *        faster implemention.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *
+ *  int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
+ *  int * B = thrust::partition_point(thrust::host, A, A + 10, is_even());
+ *  // B - A is 5
+ *  // [A, B) contains only even values
+ *  \endcode
+ *
+ *  \see \p partition
+ *  \see \p find_if_not
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename Predicate>
+__host__ __device__
+  ForwardIterator partition_point(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last,
+                                  Predicate pred);
+
+
+/*! \p partition_point returns an iterator pointing to the end of the true
+ *  partition of a partitioned range. \p partition_point requires the input range
+ *  <tt>[first,last)</tt> to be a partition; that is, all elements which satisfy
+ *  <tt>pred</tt> shall appear before those that do not.
+ *  \param first The beginning of the range to consider.
+ *  \param last The end of the range to consider.
+ *  \param pred A function object which decides to which partition each element of the
+ *              range <tt>[first, last)</tt> belongs.
+ *  \return An iterator \c mid such that <tt>all_of(first, mid, pred)</tt>
+ *          and <tt>none_of(mid, last, pred)</tt> are both true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall be partitioned by \p pred.
+ *
+ *  \note Though similar, \p partition_point is not redundant with \p find_if_not.
+ *        \p partition_point's precondition provides an opportunity for a
+ *        faster implemention.
+ *
+ *  \code
+ *  #include <thrust/partition.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *
+ *  int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
+ *  int * B = thrust::partition_point(A, A + 10, is_even());
+ *  // B - A is 5
+ *  // [A, B) contains only even values
+ *  \endcode
+ *
+ *  \see \p partition
+ *  \see \p find_if_not
+ */
+template<typename ForwardIterator, typename Predicate>
+  ForwardIterator partition_point(ForwardIterator first,
+                                  ForwardIterator last,
+                                  Predicate pred);
+
+/*! \} // searching
+ */
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup predicates
+ *  \{
+ */
+
+
+/*! \p is_partitioned returns \c true if the given range 
+ *  is partitioned with respect to a predicate, and \c false otherwise.
+ *
+ *  Specifically, \p is_partitioned returns \c true if <tt>[first, last)</tt>
+ *  is empty of if <tt>[first, last)</tt> is partitioned by \p pred, i.e. if
+ *  all elements that satisfy \p pred appear before those that do not.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to consider.
+ *  \param last The end of the range to consider.
+ *  \param pred A function object which decides to which partition each element of the
+ *         range <tt>[first, last)</tt> belongs.
+ *  \return \c true if the range <tt>[first, last)</tt> is partitioned with respect
+ *          to \p pred, or if <tt>[first, last)</tt> is empty. \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  
+ *  \code
+ *  #include <thrust/partition.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *
+ *  int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
+ *  int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *
+ *  thrust::is_partitioned(thrust::host, A, A + 10, is_even()); // returns true
+ *  thrust::is_partitioned(thrust::host, B, B + 10, is_even()); // returns false
+ *  \endcode
+ *
+ *  \see \p partition
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+  bool is_partitioned(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+/*! \p is_partitioned returns \c true if the given range 
+ *  is partitioned with respect to a predicate, and \c false otherwise.
+ *
+ *  Specifically, \p is_partitioned returns \c true if <tt>[first, last)</tt>
+ *  is empty of if <tt>[first, last)</tt> is partitioned by \p pred, i.e. if
+ *  all elements that satisfy \p pred appear before those that do not.
+ *
+ *  \param first The beginning of the range to consider.
+ *  \param last The end of the range to consider.
+ *  \param pred A function object which decides to which partition each element of the
+ *         range <tt>[first, last)</tt> belongs.
+ *  \return \c true if the range <tt>[first, last)</tt> is partitioned with respect
+ *          to \p pred, or if <tt>[first, last)</tt> is empty. \c false, otherwise.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  
+ *  \code
+ *  #include <thrust/partition.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int &x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *
+ *  int A[] = {2, 4, 6, 8, 10, 1, 3, 5, 7, 9};
+ *  int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *
+ *  thrust::is_partitioned(A, A + 10, is_even()); // returns true
+ *  thrust::is_partitioned(B, B + 10, is_even()); // returns false
+ *  \endcode
+ *
+ *  \see \p partition
+ */
+template<typename InputIterator, typename Predicate>
+  bool is_partitioned(InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+/*! \} // end predicates
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/partition.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/per_device_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/per_device_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6d620f85ec0a6fa0fc71249168e3730c0cb3189
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/per_device_resource.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>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/system/detail/generic/per_device_resource.h>
+#include <thrust/system/detail/adl/per_device_resource.h>
+#include <thrust/mr/allocator.h>
+
+#include <thrust/detail/execution_policy.h>
+#include <thrust/mr/allocator.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! Returns a global instance of \p MR for the current device of the provided system.
+ *
+ *  \tparam MR type of a memory resource to get an instance from. Must be \p DefaultConstructible.
+ *  \param system execution policy for which the resource is requested.
+ *  \return a pointer to a global instance of \p MR for the current device.
+ */
+template<typename MR, typename DerivedPolicy>
+__host__
+MR * get_per_device_resource(const thrust::detail::execution_policy_base<DerivedPolicy> & system)
+{
+    using thrust::system::detail::generic::get_per_device_resource;
+
+    return get_per_device_resource<MR>(
+        thrust::detail::derived_cast(
+            thrust::detail::strip_const(system)));
+}
+
+/*! A helper allocator class that uses global per device 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 MR the upstream memory resource to use for memory allocation. Must derive from
+ *      \p thrust::mr::memory_resource and must be \p final.
+ *  \tparam ExecutionPolicy the execution policy of the system to be used to retrieve the resource for the current device.
+ */
+template<typename T, typename Upstream, typename ExecutionPolicy>
+class per_device_allocator : public thrust::mr::allocator<T, Upstream>
+{
+    typedef thrust::mr::allocator<T, Upstream> base;
+
+public:
+    /*! The \p rebind metafunction provides the type of an \p per_device_allocator instantiated with another type.
+     *
+     *  \tparam U the other type to use for instantiation.
+     */
+    template<typename U>
+    struct rebind
+    {
+        /*! The typedef \p other gives the type of the rebound \p per_device_allocator.
+         */
+        typedef per_device_allocator<U, Upstream, ExecutionPolicy> other;
+    };
+
+    /*! Default constructor. Uses \p get_global_resource to get the global instance of \p Upstream and initializes the
+     *      \p allocator base subobject with that resource.
+     */
+    __host__
+    per_device_allocator() : base(get_per_device_resource<Upstream>(ExecutionPolicy()))
+    {
+    }
+
+    /*! Copy constructor. Copies the memory resource pointer. */
+    __host__ __device__
+    per_device_allocator(const per_device_allocator & other)
+        : base(other) {}
+
+    /*! Conversion constructor from an allocator of a different type. Copies the memory resource pointer. */
+    template<typename U>
+    __host__ __device__
+    per_device_allocator(const per_device_allocator<U, Upstream, ExecutionPolicy> & other)
+        : base(other) {}
+
+    /*! Destructor. */
+    __host__ __device__
+    ~per_device_allocator() {}
+};
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random.h
new file mode 100644
index 0000000000000000000000000000000000000000..7463620b7bceb0f3a09a47c28dabffe765baeae4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random.h
@@ -0,0 +1,117 @@
+/*
+ *  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 random.h
+ *  \brief Pseudo-random number generators.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cstdint.h>
+
+// RNGs
+#include <thrust/random/discard_block_engine.h>
+#include <thrust/random/linear_congruential_engine.h>
+#include <thrust/random/linear_feedback_shift_engine.h>
+#include <thrust/random/subtract_with_carry_engine.h>
+#include <thrust/random/xor_combine_engine.h>
+
+// distributions
+#include <thrust/random/uniform_int_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <thrust/random/normal_distribution.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup random Random Number Generation
+ *  \{
+ */
+
+
+/*! \namespace thrust::random
+ *  \brief \p thrust::random is the namespace which contains random number engine class templates,
+ *  random number engine adaptor class templates, engines with predefined parameters,
+ *  and random number distribution class templates. They are provided in a separate namespace
+ *  for import convenience but are also aliased in the top-level \p thrust namespace for
+ *  easy access.
+ */
+namespace random
+{
+
+/*! \addtogroup predefined_random Random Number Engines with Predefined Parameters
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \typedef ranlux24
+ *  \brief A random number engine with predefined parameters which implements the
+ *         RANLUX level-3 random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux24
+ *        shall produce the value \c 9901578 .
+ */
+typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
+
+
+/*! \typedef ranlux48
+ *  \brief A random number engine with predefined parameters which implements the
+ *         RANLUX level-4 random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux48
+ *        shall produce the value \c 88229545517833 .
+ */
+typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
+
+
+/*! \typedef taus88
+ *  \brief A random number engine with predefined parameters which implements
+ *         L'Ecuyer's 1996 three-component Tausworthe random number generator.
+ *
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p taus88
+ *        shall produce the value \c 3535848941 .
+ */
+typedef xor_combine_engine<
+  linear_feedback_shift_engine<thrust::detail::uint32_t, 32u, 31u, 13u, 12u>,
+  0,
+  xor_combine_engine<
+    linear_feedback_shift_engine<thrust::detail::uint32_t, 32u, 29u,  2u,  4u>, 0,
+    linear_feedback_shift_engine<thrust::detail::uint32_t, 32u, 28u,  3u, 17u>, 0
+  >,
+  0
+> taus88;
+
+/*! \typedef default_random_engine
+ *  \brief An implementation-defined "default" random number engine.
+ *  \note \p default_random_engine is currently an alias for \p minstd_rand, and may change
+ *        in a future version.
+ */
+typedef minstd_rand default_random_engine;
+
+/*! \} // end predefined_random
+ */
+
+} // end random
+
+
+/*! \} // end random
+ */
+
+// import names into thrust::
+using random::ranlux24;
+using random::ranlux48;
+using random::taus88;
+using random::default_random_engine;
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/discard_block_engine.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/discard_block_engine.inl
new file mode 100644
index 0000000000000000000000000000000000000000..31128e25061d590f4e3ebac55b7d9c762a0c93a7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/discard_block_engine.inl
@@ -0,0 +1,215 @@
+/*
+ *  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>
+
+#include <thrust/random/discard_block_engine.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine()
+      : m_e(), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine(result_type s)
+      : m_e(s), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  discard_block_engine<Engine,p,r>
+    ::discard_block_engine(const base_type &urng)
+      : m_e(urng), m_n(0)
+{}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::seed(void)
+{
+  m_e.seed();
+  m_n = 0;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::seed(result_type s)
+{
+  m_e.seed(s);
+  m_n = 0;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  typename discard_block_engine<Engine,p,r>::result_type
+    discard_block_engine<Engine,p,r>
+      ::operator()(void)
+{
+  if(m_n >= used_block)
+  {
+    m_e.discard(block_size - m_n);
+//    for(; m_n < block_size; ++m_n)
+//      m_e();
+    m_n = 0;
+  }
+
+  ++m_n;
+
+  return m_e();
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  void discard_block_engine<Engine,p,r>
+    ::discard(unsigned long long z)
+{
+  // XXX this should be accelerated
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  const typename discard_block_engine<Engine,p,r>::base_type &
+    discard_block_engine<Engine,p,r>
+      ::base(void) const
+{
+  return m_e;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& discard_block_engine<Engine,p,r>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  // output the base engine followed by n
+  os << m_e << space << m_n;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& discard_block_engine<Engine,p,r>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input the base engine and then n
+  is >> m_e >> m_n;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename Engine, size_t p, size_t r>
+  __host__ __device__
+  bool discard_block_engine<Engine,p,r>
+    ::equal(const discard_block_engine<Engine,p,r> &rhs) const
+{
+  return (m_e == rhs.m_e) && (m_n == rhs.m_n);
+}
+
+
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const discard_block_engine<Engine,p,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           discard_block_engine<Engine,p,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator==(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator!=(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine.inl
new file mode 100644
index 0000000000000000000000000000000000000000..fa9fd7d0d66b2b4675cfd84fa55d802a086df5e6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine.inl
@@ -0,0 +1,172 @@
+/*
+ *  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>
+
+#include <thrust/random/linear_congruential_engine.h>
+#include <thrust/random/detail/mod.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  linear_congruential_engine<UIntType,a,c,m>
+    ::linear_congruential_engine(result_type s)
+{
+  seed(s);
+} // end linear_congruential_engine::linear_congruential_engine()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  void linear_congruential_engine<UIntType,a,c,m>
+    ::seed(result_type s)
+{
+  if((detail::mod<UIntType, 1, 0, m>(c) == 0) &&
+     (detail::mod<UIntType, 1, 0, m>(s) == 0))
+    m_x = detail::mod<UIntType, 1, 0, m>(1);
+  else
+    m_x = detail::mod<UIntType, 1, 0, m>(s);
+} // end linear_congruential_engine::seed()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  typename linear_congruential_engine<UIntType,a,c,m>::result_type
+    linear_congruential_engine<UIntType,a,c,m>
+      ::operator()(void)
+{
+  m_x = detail::mod<UIntType,a,c,m>(m_x);
+  return m_x;
+} // end linear_congruential_engine::operator()()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  __host__ __device__
+  void linear_congruential_engine<UIntType,a,c,m>
+    ::discard(unsigned long long z)
+{
+  thrust::random::detail::linear_congruential_engine_discard::discard(*this,z);
+} // end linear_congruential_engine::discard()
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& linear_congruential_engine<UIntType,a,c,m>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(os.widen(' '));
+
+  // output one word of state
+  os << m_x;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& linear_congruential_engine<UIntType,a,c,m>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::dec);
+
+  // input one word of state
+  is >> m_x;
+
+  // restore flags
+  is.flags(flags);
+
+  return is;
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+__host__ __device__
+bool linear_congruential_engine<UIntType,a,c,m>
+  ::equal(const linear_congruential_engine<UIntType,a,c,m> &rhs) const
+{
+  return m_x == rhs.m_x;
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator==(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs)
+{
+  return detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+__host__ __device__
+bool operator!=(const linear_congruential_engine<UIntType,a,c,m> &lhs,
+                const linear_congruential_engine<UIntType,a,c,m> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_congruential_engine<UIntType_,a_,c_,m_> &e)
+{
+  return detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_congruential_engine<UIntType_,a_,c_,m_> &e)
+{
+  return detail::random_core_access::stream_in(is,e);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine_discard.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine_discard.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8103d9dc9472e3942bbb1ae4a2ada7eb0ec8885
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_congruential_engine_discard.h
@@ -0,0 +1,108 @@
+/*
+ *  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>
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/random/detail/mod.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+
+template<typename UIntType, UIntType a, unsigned long long c, UIntType m>
+  struct linear_congruential_engine_discard_implementation
+{
+  __host__ __device__
+  static void discard(UIntType &state, unsigned long long z)
+  {
+    for(; z > 0; --z)
+    {
+      state = detail::mod<UIntType,a,c,m>(state);
+    }
+  }
+}; // end linear_congruential_engine_discard
+
+
+// specialize for small integers and c == 0
+// XXX figure out a robust implemenation of this for any unsigned integer type later
+template<thrust::detail::uint32_t a, thrust::detail::uint32_t m>
+  struct linear_congruential_engine_discard_implementation<thrust::detail::uint32_t,a,0,m>
+{
+  __host__ __device__
+  static void discard(thrust::detail::uint32_t &state, unsigned long long z)
+  {
+    const thrust::detail::uint32_t modulus = m;
+
+    // XXX we need to use unsigned long long here or we will encounter overflow in the
+    //     multiplies below
+    //     figure out a robust implementation of this later
+    unsigned long long multiplier = a;
+    unsigned long long multiplier_to_z = 1;
+    
+    // see http://en.wikipedia.org/wiki/Modular_exponentiation
+    while(z > 0)
+    {
+      if(z & 1)
+      {
+        // multiply in this bit's contribution while using modulus to keep result small
+        multiplier_to_z = (multiplier_to_z * multiplier) % modulus;
+      }
+
+      // move to the next bit of the exponent, square (and mod) the base accordingly
+      z >>= 1;
+      multiplier = (multiplier * multiplier) % modulus;
+    }
+
+    state = static_cast<thrust::detail::uint32_t>((multiplier_to_z * state) % modulus);
+  }
+}; // end linear_congruential_engine_discard
+
+
+struct linear_congruential_engine_discard
+{
+  template<typename LinearCongruentialEngine>
+  __host__ __device__
+  static void discard(LinearCongruentialEngine &lcg, unsigned long long z)
+  {
+    typedef typename LinearCongruentialEngine::result_type result_type;
+    const result_type c = LinearCongruentialEngine::increment;
+    const result_type a = LinearCongruentialEngine::multiplier;
+    const result_type m = LinearCongruentialEngine::modulus;
+    
+    // XXX WAR unused variable warnings
+    (void) c;
+    (void) a;
+    (void) m;
+
+    linear_congruential_engine_discard_implementation<result_type,a,c,m>::discard(lcg.m_x, z);
+  }
+}; // end linear_congruential_engine_discard
+
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine.inl
new file mode 100644
index 0000000000000000000000000000000000000000..ac3ca86736b593fa06c3600744ea55b3275746f3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine.inl
@@ -0,0 +1,168 @@
+/*
+ *  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>
+
+#include <thrust/random/linear_feedback_shift_engine.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::linear_feedback_shift_engine(result_type value)
+{
+  seed(value);
+} // end linear_feedback_shift_engine::linear_feedback_shift_engine()
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  void linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::seed(result_type value)
+{
+  m_value = value;
+} // end linear_feedback_shift_engine::seed()
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  typename linear_feedback_shift_engine<UIntType,w,k,q,s>::result_type
+    linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::operator()(void)
+{
+  const UIntType b = (((m_value << q) ^ m_value) & wordmask) >> (k-s);
+  const UIntType mask = ( (~static_cast<UIntType>(0)) << (w-k) ) & wordmask;
+  m_value = ((m_value & mask) << s) ^ b;
+  return m_value;
+} // end linear_feedback_shift_engine::operator()()
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  void linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end linear_feedback_shift_engine::discard()
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags & fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(os.widen(' '));
+
+  // output one word of state
+  os << m_value;
+
+  // restore flags & fill character
+  os.flags(flags);
+  os.fill(fill);
+
+  return os;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& linear_feedback_shift_engine<UIntType,w,k,q,s>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input one word of state
+  is >> m_value;
+
+  // restore flags
+  is.flags(flags);
+
+  return is;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  __host__ __device__
+  bool linear_feedback_shift_engine<UIntType,w,k,q,s>
+    ::equal(const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs) const
+{
+  return m_value == rhs.m_value;
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+__host__ __device__
+bool operator==(const linear_feedback_shift_engine<UIntType,w,k,q,s> &lhs,
+                const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+__host__ __device__
+bool operator!=(const linear_feedback_shift_engine<UIntType,w,k,q,s> &lhs,
+                const linear_feedback_shift_engine<UIntType,w,k,q,s> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine_wordmask.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine_wordmask.h
new file mode 100644
index 0000000000000000000000000000000000000000..73c8ae83efb8f63b5873af18e926f8255e855c1a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/linear_feedback_shift_engine_wordmask.h
@@ -0,0 +1,48 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+template<typename T, int w, int i = w-1>
+  struct linear_feedback_shift_engine_wordmask
+{
+  static const T value =
+    (T(1u) << i) |
+    linear_feedback_shift_engine_wordmask<T, w, i-1>::value;
+}; // end linear_feedback_shift_engine_wordmask
+
+template<typename T, int w>
+  struct linear_feedback_shift_engine_wordmask<T, w, 0>
+{
+  static const T value = 0;
+}; // end linear_feedback_shift_engine_wordmask
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/mod.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/mod.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0637582de50b48d2d5bfe1a3bf688b171742ccb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/mod.h
@@ -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>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+template<typename T, T a, T c, T m, bool = (m == 0)>
+  struct static_mod
+{
+  static const T q = m / a;
+  static const T r = m % a;
+
+  __host__ __device__
+  T operator()(T x) const
+  {
+    THRUST_IF_CONSTEXPR(a == 1)
+    {
+      x %= m;
+    }
+    else
+    {
+      T t1 = a * (x % q);
+      T t2 = r * (x / q);
+      if(t1 >= t2)
+      {
+        x = t1 - t2;
+      }
+      else
+      {
+        x = m - t2 + t1;
+      }
+    }
+
+    THRUST_IF_CONSTEXPR(c != 0)
+    {
+      const T d = m - x;
+      if(d > c)
+      {
+        x += c;
+      }
+      else
+      {
+        x = c - d;
+      }
+    }
+
+    return x;
+  }
+}; // end static_mod
+
+
+// Rely on machine overflow handling
+template<typename T, T a, T c, T m>
+  struct static_mod<T,a,c,m,true>
+{
+  __host__ __device__
+  T operator()(T x) const
+  {
+    return a * x + c;
+  }
+}; // end static_mod
+
+template<typename T, T a, T c, T m>
+__host__ __device__
+  T mod(T x)
+{
+  static_mod<T,a,c,m> f;
+  return f(x);
+} // end static_mod
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution.inl
new file mode 100644
index 0000000000000000000000000000000000000000..4b69bab21394ddd22a9ac71e9d9bc97a30d08225
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution.inl
@@ -0,0 +1,257 @@
+/*
+ *  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>
+
+#include <thrust/random/normal_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/integer_traits.h>
+
+// for floating point infinity
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <math_constants.h>
+#else
+#include <limits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename RealType>
+  __host__ __device__
+  normal_distribution<RealType>
+    ::normal_distribution(RealType a, RealType b)
+      :super_t(),m_param(a,b)
+{
+} // end normal_distribution::normal_distribution()
+
+
+template<typename RealType>
+  __host__ __device__
+  normal_distribution<RealType>
+    ::normal_distribution(const param_type &parm)
+      :super_t(),m_param(parm)
+{
+} // end normal_distribution::normal_distribution()
+
+
+template<typename RealType>
+  __host__ __device__
+  void normal_distribution<RealType>
+    ::reset(void)
+{
+  super_t::reset();
+} // end normal_distribution::reset()
+
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename normal_distribution<RealType>::result_type
+      normal_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end normal_distribution::operator()()
+
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename normal_distribution<RealType>::result_type
+      normal_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng,
+                     const param_type &parm)
+{
+  return super_t::sample(urng, parm.first, parm.second);
+} // end normal_distribution::operator()()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::param_type
+    normal_distribution<RealType>
+      ::param(void) const
+{
+  return m_param;
+} // end normal_distribution::param()
+
+
+template<typename RealType>
+  __host__ __device__
+  void normal_distribution<RealType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end normal_distribution::param()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return -this->max THRUST_PREVENT_MACRO_SUBSTITUTION ();
+} // end normal_distribution::min()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  // XXX this solution is pretty terrible
+  // we can't use numeric_traits<RealType>::max because nvcc will
+  // complain that it is a __host__ function
+  union
+  {
+    thrust::detail::uint32_t inf_as_int;
+    float result;
+  } hack;
+
+  hack.inf_as_int = 0x7f800000u;
+
+  return hack.result;
+} // end normal_distribution::max()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::mean(void) const
+{
+  return m_param.first;
+} // end normal_distribution::mean()
+
+
+template<typename RealType>
+  __host__ __device__
+  typename normal_distribution<RealType>::result_type
+    normal_distribution<RealType>
+      ::stddev(void) const
+{
+  return m_param.second;
+} // end normal_distribution::stddev()
+
+
+template<typename RealType>
+  __host__ __device__
+  bool normal_distribution<RealType>
+    ::equal(const normal_distribution &rhs) const
+{
+  return m_param == rhs.param();
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      normal_distribution<RealType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << mean() << space << stddev();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      normal_distribution<RealType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator==(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator!=(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const normal_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           normal_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..a42e80014035a4b2e0c81838279ec2c0a0bd6ff3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/normal_distribution_base.h
@@ -0,0 +1,148 @@
+/*
+ *  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.
+ */
+
+/*
+ * Copyright Jens Maurer 2000-2001
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/pair.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <limits>
+#include <cmath>
+
+THRUST_NAMESPACE_BEGIN
+namespace random
+{
+namespace detail
+{
+
+// this version samples the normal distribution directly
+// and uses the non-standard math function erfcinv
+template<typename RealType>
+  class normal_distribution_nvcc
+{
+  protected:
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    RealType sample(UniformRandomNumberGenerator &urng, const RealType mean, const RealType stddev)
+    {
+      using uint_type = typename UniformRandomNumberGenerator::result_type;
+      constexpr uint_type urng_range = UniformRandomNumberGenerator::max - UniformRandomNumberGenerator::min;
+
+      // Constants for conversion
+      constexpr RealType S1 = static_cast<RealType>(1. / static_cast<double>(urng_range));
+      constexpr RealType S2 = S1 / 2;
+
+      RealType S3 = static_cast<RealType>(-1.4142135623730950488016887242097); // -sqrt(2)
+
+      // Get the integer value
+      uint_type u = urng() - UniformRandomNumberGenerator::min;
+
+      // Ensure the conversion to float will give a value in the range [0,0.5)
+      if(u > (urng_range / 2))
+      {
+        u = urng_range - u;
+        S3 = -S3;
+      }
+
+      // Convert to floating point in [0,0.5)
+      RealType p = u*S1 + S2;
+
+      // Apply inverse error function
+      return mean + stddev * S3 * erfcinv(2 * p);
+    }
+
+    // no-op
+    __host__ __device__
+    void reset() {}
+};
+
+// this version samples the normal distribution using
+// Marsaglia's "polar method"
+template<typename RealType>
+  class normal_distribution_portable
+{
+  protected:
+    normal_distribution_portable()
+      : m_r1(), m_r2(), m_cached_rho(), m_valid(false)
+    {}
+
+    normal_distribution_portable(const normal_distribution_portable &other)
+      : m_r1(other.m_r1), m_r2(other.m_r2), m_cached_rho(other.m_cached_rho), m_valid(other.m_valid)
+    {}
+
+    void reset()
+    {
+      m_valid = false;
+    }
+
+    // note that we promise to call this member function with the same mean and stddev
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    RealType sample(UniformRandomNumberGenerator &urng, const RealType mean, const RealType stddev)
+    {
+      // implementation from Boost
+      // allow for Koenig lookup
+      using std::sqrt; using std::log; using std::sin; using std::cos;
+
+      if(!m_valid)
+      {
+        uniform_real_distribution<RealType> u01;
+        m_r1 = u01(urng);
+        m_r2 = u01(urng);
+        m_cached_rho = sqrt(-RealType(2) * log(RealType(1)-m_r2));
+
+        m_valid = true;
+      }
+      else
+      {
+        m_valid = false;
+      }
+
+      const RealType pi = RealType(3.14159265358979323846);
+
+      RealType result = m_cached_rho * (m_valid ?
+                          cos(RealType(2)*pi*m_r1) :
+                          sin(RealType(2)*pi*m_r1));
+
+      return mean + stddev * result;
+    }
+
+  private:
+    RealType m_r1, m_r2, m_cached_rho;
+    bool m_valid;
+};
+
+template<typename RealType>
+  struct normal_distribution_base
+{
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC && !defined(_NVHPC_CUDA)
+  typedef normal_distribution_nvcc<RealType> type;
+#else
+  typedef normal_distribution_portable<RealType> type;
+#endif
+};
+
+} // end detail
+} // end random
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/random_core_access.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/random_core_access.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3e34e02b9334489aa3e531c2f6e1eb62f26750f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/random_core_access.h
@@ -0,0 +1,58 @@
+/*
+ *  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>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+struct random_core_access
+{
+
+template<typename OStream, typename EngineOrDistribution>
+static OStream &stream_out(OStream &os, const EngineOrDistribution &x)
+{
+  return x.stream_out(os);
+}
+
+template<typename IStream, typename EngineOrDistribution>
+static IStream &stream_in(IStream &is, EngineOrDistribution &x)
+{
+  return x.stream_in(is);
+}
+
+template<typename EngineOrDistribution>
+__host__ __device__
+static bool equal(const EngineOrDistribution &lhs, const EngineOrDistribution &rhs)
+{
+  return lhs.equal(rhs);
+}
+
+}; // end random_core_access
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/subtract_with_carry_engine.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/subtract_with_carry_engine.inl
new file mode 100644
index 0000000000000000000000000000000000000000..21c22fe775cbde77d28ce5d260d665c1aef56779
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/subtract_with_carry_engine.inl
@@ -0,0 +1,213 @@
+/*
+ *  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>
+
+#include <thrust/random/linear_congruential_engine.h>
+#include <thrust/random/subtract_with_carry_engine.h>
+#include <thrust/random/detail/mod.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  subtract_with_carry_engine<UIntType,w,s,r>
+    ::subtract_with_carry_engine(result_type value)
+{
+  seed(value);
+} // end subtract_with_carry_engine::subtract_with_carry_engine()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  void subtract_with_carry_engine<UIntType,w,s,r>
+    ::seed(result_type value)
+{
+  thrust::random::linear_congruential_engine<result_type,
+    40014u, 0u, 2147483563u> e(value == 0u ? default_seed : value);
+
+  // initialize state
+  for(size_t i = 0; i < long_lag; ++i)
+  {
+    m_x[i] = detail::mod<UIntType, 1, 0, modulus>(e());
+  } // end for i
+
+  m_carry = (m_x[long_lag-1] == 0);
+  m_k = 0;
+} // end subtract_with_carry_engine::seed()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  typename subtract_with_carry_engine<UIntType,w,s,r>::result_type
+    subtract_with_carry_engine<UIntType,w,s,r>
+      ::operator()(void)
+{
+  // XXX we probably need to cache these m_x[m_k] in a register
+  //     maybe we need to cache the use of all member variables
+  int short_index = m_k - short_lag;
+  if(short_index < 0)
+    short_index += long_lag;
+  result_type xi;
+  if (m_x[short_index] >= m_x[m_k] + m_carry)
+  {
+    // x(n) >= 0
+    xi =  m_x[short_index] - m_x[m_k] - m_carry;
+    m_carry = 0;
+  }
+  else
+  {
+    // x(n) < 0
+    xi = modulus - m_x[m_k] - m_carry + m_x[short_index];
+    m_carry = 1;
+  }
+  m_x[m_k] = xi;
+  ++m_k;
+  if(m_k >= long_lag)
+    m_k = 0;
+  return xi;
+} // end subtract_with_carry_engine::operator()()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  void subtract_with_carry_engine<UIntType,w,s,r>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end subtract_with_carry_engine::discard()
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& subtract_with_carry_engine<UIntType,w,s,r>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base     ios_base;
+
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill  = os.fill();
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  const UIntType long_lag_ = r;
+
+  for(size_t i = 0; i < r; ++i)
+    os << m_x[(i + m_k) % long_lag_] << space;
+  os << m_carry;
+
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  template<typename CharType, typename Traits>
+    std::basic_istream<CharType,Traits>& subtract_with_carry_engine<UIntType,w,s,r>
+      ::stream_in(std::basic_istream<CharType,Traits> &is)
+{
+  typedef std::basic_istream<CharType,Traits> istream_type;
+  typedef typename istream_type::ios_base     ios_base;
+
+  const typename ios_base::fmtflags flags = is.flags();
+  is.flags(ios_base::dec | ios_base::skipws);
+
+  for(size_t i = 0; i < r; ++i)
+    is >> m_x[i];
+  is >> m_carry;
+
+  m_k = 0;
+
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool subtract_with_carry_engine<UIntType,w,s,r>
+    ::equal(const subtract_with_carry_engine<UIntType,w,s,r> &rhs) const
+{
+  const UIntType long_lag_ = r;
+
+  bool result = true;
+  for(size_t i = 0; i < r; ++i)
+  {
+    result &= (m_x[(i + m_k) % long_lag_] == rhs.m_x[(i + rhs.m_k) % long_lag_]);
+  }
+
+  // XXX not sure if this last check is necessary
+  result &= (m_carry == rhs.m_carry);
+
+  return result;
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r,
+         typename CharT, typename Traits>
+  std::basic_ostream<CharT,Traits>&
+    operator<<(std::basic_ostream<CharT,Traits> &os,
+               const subtract_with_carry_engine<UIntType,w,s,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r,
+         typename CharType, typename Traits>
+  std::basic_istream<CharType,Traits>&
+    operator>>(std::basic_istream<CharType,Traits> &is,
+               subtract_with_carry_engine<UIntType,w,s,r> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool operator==(const subtract_with_carry_engine<UIntType,w,s,r> &lhs,
+                  const subtract_with_carry_engine<UIntType,w,s,r> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename UIntType, size_t w, size_t s, size_t r>
+  __host__ __device__
+  bool operator!=(const subtract_with_carry_engine<UIntType,w,s,r> &lhs,
+                  const subtract_with_carry_engine<UIntType,w,s,r> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_int_distribution.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_int_distribution.inl
new file mode 100644
index 0000000000000000000000000000000000000000..064bfcc733ba882c389db59e249e63daef220218
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_int_distribution.inl
@@ -0,0 +1,249 @@
+/*
+ *  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>
+
+#include <thrust/random/uniform_int_distribution.h>
+#include <thrust/random/uniform_real_distribution.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename IntType>
+  __host__ __device__
+  uniform_int_distribution<IntType>
+    ::uniform_int_distribution(IntType a, IntType b)
+      :m_param(a,b)
+{
+} // end uniform_int_distribution::uniform_int_distribution()
+
+
+template<typename IntType>
+  __host__ __device__
+  uniform_int_distribution<IntType>
+    ::uniform_int_distribution(const param_type &parm)
+      :m_param(parm)
+{
+} // end uniform_int_distribution::uniform_int_distribution()
+
+
+template<typename IntType>
+  __host__ __device__
+  void uniform_int_distribution<IntType>
+    ::reset(void)
+{
+} // end uniform_int_distribution::reset()
+
+
+template<typename IntType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_int_distribution<IntType>::result_type
+      uniform_int_distribution<IntType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_int_distribution::operator()()
+
+
+template<typename IntType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_int_distribution<IntType>::result_type
+      uniform_int_distribution<IntType>
+        ::operator()(UniformRandomNumberGenerator &urng, const param_type &parm)
+{
+  // XXX this implementation is somewhat hacky and will skip
+  //     values if the range of the RNG is smaller than the range of the distribution
+  //     we should improve this implementation in a later version
+
+  typedef typename thrust::detail::largest_available_float::type float_type;
+
+  const float_type real_min(static_cast<float_type>(parm.first));
+  const float_type real_max(static_cast<float_type>(parm.second));
+
+  // add one to the right end of the interval because it is half-open
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  uniform_real_distribution<float_type> real_dist(real_min, real_max + float_type(1));
+
+  return static_cast<result_type>(real_dist(urng));
+} // end uniform_int_distribution::operator()()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::a(void) const
+{
+  return m_param.first;
+} // end uniform_int_distribution<IntType>::a()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::b(void) const
+{
+  return m_param.second;
+} // end uniform_int_distribution::b()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::param_type
+    uniform_int_distribution<IntType>
+      ::param(void) const
+{
+  return m_param;
+} // end uniform_int_distribution::param()
+
+
+template<typename IntType>
+  __host__ __device__
+  void uniform_int_distribution<IntType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end uniform_int_distribution::param()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return a();
+} // end uniform_int_distribution::min()
+
+
+template<typename IntType>
+  __host__ __device__
+  typename uniform_int_distribution<IntType>::result_type
+    uniform_int_distribution<IntType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return b();
+} // end uniform_int_distribution::max()
+
+
+template<typename IntType>
+  __host__ __device__
+  bool uniform_int_distribution<IntType>
+    ::equal(const uniform_int_distribution &rhs) const
+{
+  return param() == rhs.param();
+}
+
+
+template<typename IntType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      uniform_int_distribution<IntType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename IntType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      uniform_int_distribution<IntType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename IntType>
+__host__ __device__
+bool operator==(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename IntType>
+__host__ __device__
+bool operator!=(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_int_distribution<IntType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_int_distribution<IntType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_real_distribution.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_real_distribution.inl
new file mode 100644
index 0000000000000000000000000000000000000000..119f82c1ebaa6d2088ac520932a48170fb47b573
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/uniform_real_distribution.inl
@@ -0,0 +1,234 @@
+/*
+ *  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>
+
+#include <thrust/random/uniform_real_distribution.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+template<typename RealType>
+  __host__ __device__
+  uniform_real_distribution<RealType>
+    ::uniform_real_distribution(RealType a, RealType b)
+      :m_param(a,b)
+{
+} // end uniform_real_distribution::uniform_real_distribution()
+
+template<typename RealType>
+  __host__ __device__
+  uniform_real_distribution<RealType>
+    ::uniform_real_distribution(const param_type &parm)
+      :m_param(parm)
+{
+} // end uniform_real_distribution::uniform_real_distribution()
+
+template<typename RealType>
+  __host__ __device__
+  void uniform_real_distribution<RealType>
+    ::reset(void)
+{
+} // end uniform_real_distribution::reset()
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_real_distribution<RealType>::result_type
+      uniform_real_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng)
+{
+  return operator()(urng, m_param);
+} // end uniform_real::operator()()
+
+template<typename RealType>
+  template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    typename uniform_real_distribution<RealType>::result_type
+      uniform_real_distribution<RealType>
+        ::operator()(UniformRandomNumberGenerator &urng,
+                     const param_type &parm)
+{
+  // call the urng & map its result to [0,1)
+  result_type result = static_cast<result_type>(urng() - UniformRandomNumberGenerator::min);
+
+  // adding one to the denominator ensures that the interval is half-open at 1.0
+  // XXX adding 1.0 to a potentially large floating point number seems like a bad idea
+  // XXX OTOH adding 1 to what is potentially UINT_MAX also seems like a bad idea
+  // XXX we could statically check if 1u + (max - min) is representable and do that, otherwise use the current implementation
+  result /= (result_type(1) + static_cast<result_type>(UniformRandomNumberGenerator::max - UniformRandomNumberGenerator::min));
+
+  return (result * (parm.second - parm.first)) + parm.first;
+} // end uniform_real::operator()()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::a(void) const
+{
+  return m_param.first;
+} // end uniform_real::a()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::b(void) const
+{
+  return m_param.second;
+} // end uniform_real_distribution::b()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::param_type
+    uniform_real_distribution<RealType>
+      ::param(void) const
+{
+  return m_param;;
+} // end uniform_real_distribution::param()
+
+template<typename RealType>
+  __host__ __device__
+  void uniform_real_distribution<RealType>
+    ::param(const param_type &parm)
+{
+  m_param = parm;
+} // end uniform_real_distribution::param()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return a();
+} // end uniform_real_distribution::min()
+
+template<typename RealType>
+  __host__ __device__
+  typename uniform_real_distribution<RealType>::result_type
+    uniform_real_distribution<RealType>
+      ::max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const
+{
+  return b();
+} // end uniform_real_distribution::max()
+
+
+template<typename RealType>
+  __host__ __device__
+  bool uniform_real_distribution<RealType>
+    ::equal(const uniform_real_distribution &rhs) const
+{
+  return m_param == rhs.param();
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>&
+      uniform_real_distribution<RealType>
+        ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  os << a() << space << b();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename RealType>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>&
+      uniform_real_distribution<RealType>
+        ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  is >> m_param.first >> m_param.second;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator==(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename RealType>
+__host__ __device__
+bool operator!=(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_real_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,d);
+}
+
+
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_real_distribution<RealType> &d)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,d);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine.inl
new file mode 100644
index 0000000000000000000000000000000000000000..c948214438ffd73db4d2c96fdfb059b53fbbdfb9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine.inl
@@ -0,0 +1,218 @@
+/*
+ *  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>
+
+#include <thrust/random/xor_combine_engine.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(void)
+      :m_b1(),m_b2()
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(const base1_type &urng1, const base2_type &urng2)
+      :m_b1(urng1),m_b2(urng2)
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::xor_combine_engine(result_type s)
+      :m_b1(s),m_b2(s)
+{
+} // end xor_combine_engine::xor_combine_engine()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::seed(void)
+{
+  m_b1.seed();
+  m_b2.seed();
+} // end xor_combine_engine::seed()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::seed(result_type s)
+{
+  m_b1.seed(s);
+  m_b2.seed(s);
+} // end xor_combine_engine::seed()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  const typename xor_combine_engine<Engine1,s1,Engine2,s2>::base1_type &
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::base1(void) const
+{
+  return m_b1;
+} // end xor_combine_engine::base1()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  const typename xor_combine_engine<Engine1,s1,Engine2,s2>::base2_type &
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::base2(void) const
+{
+  return m_b2;
+} // end xor_combine_engine::base2()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  typename xor_combine_engine<Engine1,s1,Engine2,s2>::result_type
+    xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::operator()(void)
+{
+  return (result_type(m_b1() - base1_type::min) << shift1) ^
+         (result_type(m_b2() - base2_type::min) << shift2);
+} // end xor_combine_engine::operator()()
+
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2>
+  __host__ __device__
+  void xor_combine_engine<Engine1, s1, Engine2, s2>
+    ::discard(unsigned long long z)
+{
+  for(; z > 0; --z)
+  {
+    this->operator()();
+  } // end for
+} // end xor_combine_engine::discard()
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::stream_out(std::basic_ostream<CharT,Traits> &os) const
+{
+  typedef std::basic_ostream<CharT,Traits> ostream_type;
+  typedef typename ostream_type::ios_base  ios_base;
+
+  // save old flags and fill character
+  const typename ios_base::fmtflags flags = os.flags();
+  const CharT fill = os.fill();
+
+  const CharT space = os.widen(' ');
+  os.flags(ios_base::dec | ios_base::fixed | ios_base::left);
+  os.fill(space);
+
+  // output each base engine in turn
+  os << base1() << space << base2();
+
+  // restore old flags and fill character
+  os.flags(flags);
+  os.fill(fill);
+  return os;
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& xor_combine_engine<Engine1,s1,Engine2,s2>
+      ::stream_in(std::basic_istream<CharT,Traits> &is)
+{
+  typedef std::basic_istream<CharT,Traits> istream_type;
+  typedef typename istream_type::ios_base  ios_base;
+
+  // save old flags
+  const typename ios_base::fmtflags flags = is.flags();
+
+  is.flags(ios_base::skipws);
+
+  // input each base engine in turn
+  is >> m_b1 >> m_b2;
+
+  // restore old flags
+  is.flags(flags);
+  return is;
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+  __host__ __device__
+  bool xor_combine_engine<Engine1,s1,Engine2,s2>
+    ::equal(const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs) const
+{
+  return (m_b1 == rhs.m_b1) && (m_b2 == rhs.m_b2);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const xor_combine_engine<Engine1,s1,Engine2,s2> &e)
+{
+  return thrust::random::detail::random_core_access::stream_out(os,e);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           xor_combine_engine<Engine1,s1,Engine2,s2> &e)
+{
+  return thrust::random::detail::random_core_access::stream_in(is,e);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+__host__ __device__
+bool operator==(const xor_combine_engine<Engine1,s1,Engine2,s2> &lhs,
+                const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs)
+{
+  return thrust::random::detail::random_core_access::equal(lhs,rhs);
+}
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2>
+__host__ __device__
+bool operator!=(const xor_combine_engine<Engine1,s1,Engine2,s2> &lhs,
+                const xor_combine_engine<Engine1,s1,Engine2,s2> &rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine_max.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine_max.h
new file mode 100644
index 0000000000000000000000000000000000000000..0756ff9e04c8c0e64104d7279cd488717cbb8d0c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/detail/xor_combine_engine_max.h
@@ -0,0 +1,325 @@
+/*
+ *  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>
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/mpl/math.h>
+#include <limits>
+#include <cstddef>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+namespace detail
+{
+
+
+namespace math = thrust::detail::mpl::math;
+
+
+namespace detail
+{
+
+// two cases for this function avoids compile-time warnings of overflow
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs,
+         bool shift_will_overflow>
+  struct lshift_w
+{
+  static const UIntType value = 0;
+};
+
+
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs>
+  struct lshift_w<UIntType,w,lhs,rhs,false>
+{
+  static const UIntType value = lhs << rhs;
+};
+
+} // end detail
+
+
+template<typename UIntType, UIntType w,
+         UIntType lhs, UIntType rhs>
+  struct lshift_w
+{
+  static const bool shift_will_overflow = rhs >= w;
+
+  static const UIntType value = detail::lshift_w<UIntType, w, lhs, rhs, shift_will_overflow>::value;
+};
+
+
+template<typename UIntType, UIntType lhs, UIntType rhs>
+  struct lshift
+    : lshift_w<UIntType, std::numeric_limits<UIntType>::digits, lhs, rhs>
+{};
+
+
+template<typename UIntType, int p>
+  struct two_to_the_power
+    : lshift<UIntType, 1, p>
+{};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  class xor_combine_engine_max_aux_constants
+{
+  public:
+    static const result_type two_to_the_d = two_to_the_power<result_type, d>::value;
+    static const result_type c = lshift<result_type, a, d>::value;
+
+    static const result_type t =
+      math::max<
+        result_type,
+        c,
+        b
+      >::value;
+
+    static const result_type u =
+      math::min<
+        result_type,
+        c,
+        b
+      >::value;
+
+    static const result_type p            = math::log2<u>::value;
+    static const result_type two_to_the_p = two_to_the_power<result_type, p>::value;
+
+    static const result_type k = math::div<result_type, t, two_to_the_p>::value;
+};
+
+
+template<typename result_type, result_type, result_type, int> struct xor_combine_engine_max_aux;
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case4
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      math::div<
+        result_type,
+        math::mod<
+          result_type,
+          constants::u,
+          constants::two_to_the_p
+        >::value,
+        constants::two_to_the_p
+      >::value,
+      math::mod<
+        result_type,
+        constants::t,
+        constants::two_to_the_p
+      >::value,
+      d
+    >::value;
+
+  static const result_type value = math::plus<result_type, k_plus_1_times_two_to_the_p, M>::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case3
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      math::div<
+        result_type,
+        math::mod<
+          result_type,
+          constants::t,
+          constants::two_to_the_p
+        >::value,
+        constants::two_to_the_p
+      >::value,
+      math::mod<
+        result_type,
+        constants::u,
+        constants::two_to_the_p
+      >::value,
+      d
+    >::value;
+
+  static const result_type value = math::plus<result_type, k_plus_1_times_two_to_the_p, M>::value;
+};
+
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case2
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type k_plus_1_times_two_to_the_p =
+    lshift<
+      result_type,
+      math::plus<result_type,constants::k,1>::value,
+      constants::p
+    >::value;
+
+  static const result_type value =
+    math::minus<
+      result_type,
+      k_plus_1_times_two_to_the_p,
+      1
+    >::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_case1
+{
+  static const result_type c     = lshift<result_type, a, d>::value;
+
+  static const result_type value = math::plus<result_type,c,b>::value;
+};
+
+
+template<typename result_type, result_type a, result_type b, int d>
+  struct xor_combine_engine_max_aux_2
+{
+  typedef xor_combine_engine_max_aux_constants<result_type,a,b,d> constants;
+
+  static const result_type value = 
+    thrust::detail::eval_if<
+      // if k is odd...
+      math::is_odd<result_type, constants::k>::value,
+      thrust::detail::identity_<
+        thrust::detail::integral_constant<
+          result_type,
+          xor_combine_engine_max_aux_case2<result_type,a,b,d>::value
+        >
+      >,
+      thrust::detail::eval_if<
+        // otherwise if a * 2^3 >= b, then case 3
+        a * constants::two_to_the_d >= b,
+        thrust::detail::identity_<
+          thrust::detail::integral_constant<
+            result_type,
+            xor_combine_engine_max_aux_case3<result_type,a,b,d>::value
+          >
+        >,
+        // otherwise, case 4
+        thrust::detail::identity_<
+          thrust::detail::integral_constant<
+            result_type,
+            xor_combine_engine_max_aux_case4<result_type,a,b,d>::value
+          >
+        >
+      >
+    >::type::value;
+};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d,
+         bool use_case1 = (a == 0) || (b < two_to_the_power<result_type,d>::value)>
+  struct xor_combine_engine_max_aux_1
+    : xor_combine_engine_max_aux_case1<result_type,a,b,d>
+{};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d>
+  struct xor_combine_engine_max_aux_1<result_type,a,b,d,false>
+    : xor_combine_engine_max_aux_2<result_type,a,b,d>
+{};
+
+
+template<typename result_type,
+         result_type a,
+         result_type b,
+         int d>
+  struct xor_combine_engine_max_aux
+    : xor_combine_engine_max_aux_1<result_type,a,b,d>
+{};
+
+
+template<typename Engine1, size_t s1, typename Engine2, size_t s2, typename result_type>
+  struct xor_combine_engine_max
+{
+  static const size_t w = std::numeric_limits<result_type>::digits;
+
+  static const result_type m1 =
+    math::min<
+      result_type,
+      result_type(Engine1::max - Engine1::min),
+      two_to_the_power<result_type, w-s1>::value - 1 
+    >::value;
+
+  static const result_type m2 =
+    math::min<
+      result_type,
+      result_type(Engine2::max - Engine2::min),
+      two_to_the_power<result_type, w-s2>::value - 1
+    >::value;
+
+  static const result_type s = s1 - s2;
+
+  static const result_type M =
+    xor_combine_engine_max_aux<
+      result_type,
+      m1,
+      m2,
+      s
+    >::value;
+
+  // the value is M(m1,m2,s) lshift_w s2
+  static const result_type value =
+    lshift_w<
+      result_type,
+      w,
+      M,
+      s2
+    >::value;
+}; // end xor_combine_engine_max
+
+} // end detail
+
+} // end random
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/discard_block_engine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/discard_block_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..88e1155861e63df6c7970c98b0c14af911278932
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/discard_block_engine.h
@@ -0,0 +1,251 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file discard_block_engine.h
+ *  \brief A random number engine which adapts a base engine and produces
+ *         numbers by discarding all but a contiguous blocks of its values.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/config.h>
+#include <iostream>
+#include <thrust/detail/cstdint.h>
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_adaptors Random Number Engine Adaptor Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class discard_block_engine
+ *  \brief A \p discard_block_engine adapts an existing base random number engine and produces
+ *         random values by discarding some of the values returned by its base engine.
+ *         Each cycle of the compound engine begins by returning \c r values successively produced
+ *         by the base engine and ends by discarding <tt>p-r</tt> such values. The engine's state
+ *         is the state of its base engine followed by the number of calls to <tt>operator()</tt>
+ *         that have occurred since the beginning of the current cycle.
+ *
+ *  \tparam Engine The type of the base random number engine to adapt.
+ *  \tparam p The discard cycle length.
+ *  \tparam r The number of values to return of the base engine. Because <tt>p-r</tt> will be
+ *            discarded, <tt>r <= p</tt>.
+ *
+ *  The following code snippet shows an example of using a \p discard_block_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/discard_block_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create a discard_block_engine from minstd_rand, with a cycle length of 13
+ *    // keep every first 10 values, and discard the next 3
+ *    thrust::discard_block_engine<thrust::minstd_rand, 13, 10> rng;
+ *
+ *    // print a random number to standard output
+ *    std::cout << rng() << std::endl;
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */         
+template<typename Engine, size_t p, size_t r>
+  class discard_block_engine
+{
+  public:
+    // types
+
+    /*! \typedef base_type
+     *  \brief The type of the adapted base random number engine.
+     */
+    typedef Engine base_type;
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_congruential_engine.
+     */
+    typedef typename base_type::result_type result_type;
+
+    // engine characteristics
+
+    /*! The length of the production cycle.
+     */
+    static const size_t block_size = p;
+
+    /*! The number of used numbers per production cycle.
+     */
+    static const size_t used_block = r;
+
+    /*! The smallest value this \p discard_block_engine may potentially produce.
+     */
+    static const result_type min = base_type::min;
+
+    /*! The largest value this \p discard_block_engine may potentially produce.
+     */
+    static const result_type max = base_type::max;
+
+    // constructors and seeding functions
+
+    /*! This constructor constructs a new \p discard_block_engine and constructs
+     *  its \p base_type engine using its null constructor.
+     */
+    __host__ __device__
+    discard_block_engine();
+
+    /*! This constructor constructs a new \p discard_block_engine using
+     *  a given \p base_type engine to initialize its adapted base engine.
+     *
+     *  \param urng A \p base_type to use to initialize this \p discard_block_engine's
+     *         adapted base engine.
+     */
+    __host__ __device__
+    explicit discard_block_engine(const base_type &urng);
+
+    /*! This constructor initializes a new \p discard_block_engine with a given seed.
+     *  
+     *  \param s The seed used to intialize this \p discard_block_engine's adapted base engine.
+     */
+    __host__ __device__
+    explicit discard_block_engine(result_type s);
+
+    /*! This method initializes the state of this \p discard_block_engine's adapted base engine
+     *  by using its \p default_seed value.
+     */
+    __host__ __device__
+    void seed(void);
+
+    /*! This method initializes the state of this \p discard_block_engine's adapted base engine
+     *  by using the given seed.
+     *
+     *  \param s The seed with which to intialize this \p discard_block_engine's adapted base engine.
+     */
+    __host__ __device__
+    void seed(result_type s);
+
+    // generating functions
+    
+    /*! This member function produces a new random value and updates this \p discard_block_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p discard_block_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    // property functions
+
+    /*! This member function returns a const reference to this \p discard_block_engine's
+     *  adapted base engine.
+     *
+     *  \return A const reference to the base engine this \p discard_block_engine adapts.
+     */
+    __host__ __device__
+    const base_type &base(void) const;
+
+    /*! \cond
+     */
+  private:
+    base_type m_e;
+    unsigned int m_n;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const discard_block_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end discard_block_engine
+
+
+/*! This function checks two \p discard_block_engines for equality.
+ *  \param lhs The first \p discard_block_engine to test.
+ *  \param rhs The second \p discard_block_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator==(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs);
+
+
+/*! This function checks two \p discard_block_engines for inequality.
+ *  \param lhs The first \p discard_block_engine to test.
+ *  \param rhs The second \p discard_block_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine, size_t p, size_t r>
+__host__ __device__
+bool operator!=(const discard_block_engine<Engine,p,r> &lhs,
+                const discard_block_engine<Engine,p,r> &rhs);
+
+
+/*! This function streams a discard_block_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p discard_block_engine to stream out.
+ *  \return \p os
+ */
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const discard_block_engine<Engine,p,r> &e);
+
+
+/*! This function streams a discard_block_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p discard_block_engine to stream in.
+ *  \return \p is
+ */
+template<typename Engine, size_t p, size_t r,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           discard_block_engine<Engine,p,r> &e);
+
+/*! \} // end random_number_engine_adaptors
+ */
+
+} // end random
+
+// import names into thrust::
+using random::discard_block_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/discard_block_engine.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_congruential_engine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_congruential_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..dac03d90eb2eac11ef312e5d472bbbbed01bf992
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_congruential_engine.h
@@ -0,0 +1,294 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file linear_congruential_engine.h
+ *  \brief A linear congruential pseudorandom number engine.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <iostream>
+#include <thrust/detail/cstdint.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <thrust/random/detail/linear_congruential_engine_discard.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_templates Random Number Engine Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class linear_congruential_engine
+ *  \brief A \p linear_congruential_engine random number engine produces unsigned integer
+ *         random numbers using a linear congruential random number generation algorithm.
+ *
+ *         The generation algorithm has the form <tt>x_i = (a * x_{i-1} + c) mod m</tt>.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam a The multiplier used in the generation algorithm.
+ *  \tparam c The increment used in the generation algorithm.
+ *  \tparam m The modulus used in the generation algorithm.
+ *
+ *  \note Inexperienced users should not use this class template directly.  Instead, use
+ *  \p minstd_rand or \p minstd_rand0.
+ *
+ *  The following code snippet shows examples of use of a \p linear_congruential_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object, which is an instance of linear_congruential_engine
+ *    thrust::minstd_rand rng1;
+ *
+ *    // output some random values to cout
+ *    std::cout << rng1() << std::endl;
+ *
+ *    // a random value is printed
+ *
+ *    // create a new minstd_rand from a seed
+ *    thrust::minstd_rand rng2(13);
+ *
+ *    // discard some random values
+ *    rng2.discard(13);
+ *
+ *    // stream the object to an iostream
+ *    std::cout << rng2 << std::endl;
+ *
+ *    // rng2's current state is printed
+ *
+ *    // print the minimum and maximum values that minstd_rand can produce
+ *    std::cout << thrust::minstd_rand::min << std::endl;
+ *    std::cout << thrust::minstd_rand::max << std::endl;
+ *
+ *    // the range of minstd_rand is printed
+ *
+ *    // save the state of rng2 to a different object
+ *    thrust::minstd_rand rng3 = rng2;
+ *
+ *    // compare rng2 and rng3
+ *    std::cout << (rng2 == rng3) << std::endl;
+ *
+ *    // 1 is printed
+ *
+ *    // re-seed rng2 with a different seed
+ *    rng2.seed(7);
+ *
+ *    // compare rng2 and rng3
+ *    std::cout << (rng2 == rng3) << std::endl;
+ *
+ *    // 0 is printed
+ *
+ *    return 0;
+ *  }
+ *
+ *  \endcode
+ *
+ *  \see thrust::random::minstd_rand
+ *  \see thrust::random::minstd_rand0
+ */
+template<typename UIntType, UIntType a, UIntType c, UIntType m>
+  class linear_congruential_engine
+{
+  public:
+    // types
+    
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_congruential_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The multiplier used in the generation algorithm.
+     */
+    static const result_type multiplier = a;
+
+    /*! The increment used in the generation algorithm.
+     */
+    static const result_type increment = c;
+
+    /*! The modulus used in the generation algorithm.
+     */
+    static const result_type modulus = m;
+
+    /*! The smallest value this \p linear_congruential_engine may potentially produce.
+     */
+    static const result_type min = c == 0u ? 1u : 0u;
+
+    /*! The largest value this \p linear_congruential_engine may potentially produce.
+     */
+    static const result_type max = m - 1u;
+
+    /*! The default seed of this \p linear_congruential_engine.
+     */
+    static const result_type default_seed = 1u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p linear_congruential_engine.
+     *  
+     *  \param s The seed used to intialize this \p linear_congruential_engine's state.
+     */
+    __host__ __device__
+    explicit linear_congruential_engine(result_type s = default_seed);
+
+    /*! This method initializes this \p linear_congruential_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param s The seed used to initializes this \p linear_congruential_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type s = default_seed);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p linear_congruential_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p linear_congruential_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_x;
+
+    static void transition(result_type &state);
+
+    friend struct thrust::random::detail::random_core_access;
+
+    friend struct thrust::random::detail::linear_congruential_engine_discard;
+
+    __host__ __device__
+    bool equal(const linear_congruential_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end linear_congruential_engine
+
+
+/*! This function checks two \p linear_congruential_engines for equality.
+ *  \param lhs The first \p linear_congruential_engine to test.
+ *  \param rhs The second \p linear_congruential_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator==(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs);
+
+
+/*! This function checks two \p linear_congruential_engines for inequality.
+ *  \param lhs The first \p linear_congruential_engine to test.
+ *  \param rhs The second \p linear_congruential_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_>
+__host__ __device__
+bool operator!=(const linear_congruential_engine<UIntType_,a_,c_,m_> &lhs,
+                const linear_congruential_engine<UIntType_,a_,c_,m_> &rhs);
+
+
+/*! This function streams a linear_congruential_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p linear_congruential_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_congruential_engine<UIntType_,a_,c_,m_> &e);
+
+
+/*! This function streams a linear_congruential_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p linear_congruential_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, UIntType_ a_, UIntType_ c_, UIntType_ m_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_congruential_engine<UIntType_,a_,c_,m_> &e);
+
+
+/*! \} // random_number_engine_templates
+ */
+
+
+/*! \addtogroup predefined_random
+ *  \{
+ */
+
+// XXX the type N2111 used here was uint_fast32_t
+
+/*! \typedef minstd_rand0
+ *  \brief A random number engine with predefined parameters which implements a version of
+ *         the Minimal Standard random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p minstd_rand0
+ *        shall produce the value \c 1043618065 .
+ */
+typedef linear_congruential_engine<thrust::detail::uint32_t, 16807, 0, 2147483647> minstd_rand0;
+
+
+/*! \typedef minstd_rand
+ *  \brief A random number engine with predefined parameters which implements a version of
+ *         the Minimal Standard random number generation algorithm.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p minstd_rand
+ *        shall produce the value \c 399268537 .
+ */
+typedef linear_congruential_engine<thrust::detail::uint32_t, 48271, 0, 2147483647> minstd_rand;
+
+/*! \} // predefined_random
+ */
+  
+} // end random
+
+// import names into thrust::
+using random::linear_congruential_engine;
+using random::minstd_rand;
+using random::minstd_rand0;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/linear_congruential_engine.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_feedback_shift_engine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_feedback_shift_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..a46c6d8ab8a6164c95f825119d2787509866a78d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/linear_feedback_shift_engine.h
@@ -0,0 +1,229 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file linear_feedback_shift_engine.h
+ *  \brief A linear feedback shift pseudorandom number generator.
+ */
+
+/*
+ * Copyright Jens Maurer 2002
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/random/detail/linear_feedback_shift_engine_wordmask.h>
+#include <iostream>
+#include <cstddef> // for size_t
+#include <thrust/random/detail/random_core_access.h>
+
+THRUST_NAMESPACE_BEGIN
+
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_templates
+ *  \{
+ */
+
+/*! \class linear_feedback_shift_engine
+ *  \brief A \p linear_feedback_shift_engine random number engine produces
+ *         unsigned integer random values using a linear feedback shift random number
+ *         generation algorithm.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam w The word size of the produced values (<tt>w <= sizeof(UIntType)</tt>).
+ *  \tparam k The k parameter of Tausworthe's 1965 algorithm.
+ *  \tparam q The q exponent of Tausworthe's 1965 algorithm.
+ *  \tparam s The step size of Tausworthe's 1965 algorithm.
+ *
+ *  \note linear_feedback_shift_engine is based on the Boost Template Library's linear_feedback_shift.
+ */
+template<typename UIntType, size_t w, size_t k, size_t q, size_t s>
+  class linear_feedback_shift_engine
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p linear_feedback_shift_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The word size of the produced values.
+     */
+    static const size_t word_size = w;
+
+    /*! A constant used in the generation algorithm.
+     */
+    static const size_t exponent1 = k;
+
+    /*! A constant used in the generation algorithm.
+     */
+    static const size_t exponent2 = q;
+
+    /*! The step size used in the generation algorithm.
+     */
+    static const size_t step_size = s;
+
+    /*! \cond
+     */
+  private:
+    static const result_type wordmask =
+      detail::linear_feedback_shift_engine_wordmask<
+        result_type,
+        w
+      >::value;
+    /*! \endcond
+     */
+
+  public:
+
+    /*! The smallest value this \p linear_feedback_shift_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p linear_feedback_shift_engine may potentially produce.
+     */
+    static const result_type max = wordmask;
+
+    /*! The default seed of this \p linear_feedback_shift_engine.
+     */
+    static const result_type default_seed = 341u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p linear_feedback_shift_engine.
+     *  
+     *  \param value The seed used to intialize this \p linear_feedback_shift_engine's state.
+     */
+    __host__ __device__
+    explicit linear_feedback_shift_engine(result_type value = default_seed);
+
+    /*! This method initializes this \p linear_feedback_shift_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param value The seed used to initializes this \p linear_feedback_shift_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type value = default_seed);
+
+    // generating functions
+    
+    /*! This member function produces a new random value and updates this \p linear_feedback_shift_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p linear_feedback_shift_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_value;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const linear_feedback_shift_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end linear_feedback_shift_engine
+
+
+/*! This function checks two \p linear_feedback_shift_engines for equality.
+ *  \param lhs The first \p linear_feedback_shift_engine to test.
+ *  \param rhs The second \p linear_feedback_shift_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
+__host__ __device__
+bool operator==(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
+                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
+
+
+/*! This function checks two \p linear_feedback_shift_engines for inequality.
+ *  \param lhs The first \p linear_feedback_shift_engine to test.
+ *  \param rhs The second \p linear_feedback_shift_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_>
+__host__ __device__
+bool operator!=(const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &lhs,
+                const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &rhs);
+
+
+/*! This function streams a linear_feedback_shift_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p linear_feedback_shift_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
+
+
+/*! This function streams a linear_feedback_shift_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p linear_feedback_shift_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, size_t w_, size_t k_, size_t q_, size_t s_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           linear_feedback_shift_engine<UIntType_,w_,k_,q_,s_> &e);
+
+
+/*! \} // end random_number_engine_templates
+ */
+
+
+} // end random
+
+// import names into thrust::
+using random::linear_feedback_shift_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/linear_feedback_shift_engine.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/normal_distribution.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/normal_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..36b985cb6854733874b00f89abcf03e16107912f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/normal_distribution.h
@@ -0,0 +1,274 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file normal_distribution.h
+ *  \brief A normal (Gaussian) distribution of real-valued numbers.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/pair.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <thrust/random/detail/normal_distribution_base.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_distributions
+ *  \{
+ */
+
+/*! \class normal_distribution
+ *  \brief A \p normal_distribution random number distribution produces floating point
+ *         Normally distributed random numbers.
+ *
+ *  \tparam RealType The type of floating point number to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p normal_distribution with a 
+ *  random number engine to produce random values drawn from the Normal distribution with a given
+ *  mean and variance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/normal_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a normal_distribution to produce floats from the Normal distribution
+ *    // with mean 2.0 and standard deviation 3.5
+ *    thrust::random::normal_distribution<float> dist(2.0f, 3.5f);
+ *
+ *    // write a random number to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the mean of the distribution, just in case we forgot
+ *    std::cout << dist.mean() << std::endl;
+ *
+ *    // 2.0 is printed
+ *
+ *    // and the standard deviation
+ *    std::cout << dist.stddev() << std::endl;
+ *
+ *    // 3.5 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename RealType = double>
+  class normal_distribution
+    : public detail::normal_distribution_base<RealType>::type
+{
+  private:
+    typedef typename detail::normal_distribution_base<RealType>::type super_t;
+
+  public:
+    // types
+    
+    /*! \typedef result_type
+     *  \brief The type of the floating point number produced by this \p normal_distribution.
+     */
+    typedef RealType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p normal_distribution's parameters.
+     */
+    typedef thrust::pair<RealType,RealType> param_type;
+
+    // constructors and reset functions
+    
+    /*! This constructor creates a new \p normal_distribution from two values defining the
+     *  half-open interval of the distribution.
+     *  
+     *  \param mean The mean (expected value) of the distribution. Defaults to \c 0.0.
+     *  \param stddev The standard deviation of the distribution. Defaults to \c 1.0.
+     */
+    __host__ __device__
+    explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
+
+    /*! This constructor creates a new \p normal_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *  
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of the distribution.
+     */
+    __host__ __device__
+    explicit normal_distribution(const param_type &parm);
+
+    /*! Calling this member function guarantees that subsequent uses of this
+     *  \p normal_distribution do not depend on values produced by any random
+     *  number generator prior to invoking this function.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new Normal random integer drawn from this \p normal_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new Normal random integer as if by creating a new \p normal_distribution 
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p normal_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+
+    /*! This method returns the value of the parameter with which this \p normal_distribution
+     *  was constructed.
+     *
+     *  \return The mean (expected value) of this \p normal_distribution's output.
+     */
+    __host__ __device__
+    result_type mean(void) const;
+
+    /*! This method returns the value of the parameter with which this \p normal_distribution
+     *  was constructed.
+     *
+     *  \return The standard deviation of this \p uniform_real_distribution's output.
+     */
+    __host__ __device__
+    result_type stddev(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p normal_distribution was constructed.
+     *
+     *  \return A \p param_type object encapsulating the parameters (i.e., the mean and standard deviation) of this \p normal_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p normal_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new parameters (i.e., the mean and variance) of this \p normal_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest floating point number this \p normal_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p normal_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the smallest number larger than largest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p normal_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const normal_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end normal_distribution
+
+
+/*! This function checks two \p normal_distributions for equality.
+ *  \param lhs The first \p normal_distribution to test.
+ *  \param rhs The second \p normal_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator==(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs);
+
+
+/*! This function checks two \p normal_distributions for inequality.
+ *  \param lhs The first \p normal_distribution to test.
+ *  \param rhs The second \p normal_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator!=(const normal_distribution<RealType> &lhs,
+                const normal_distribution<RealType> &rhs);
+
+
+/*! This function streams a normal_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p normal_distribution to stream out.
+ *  \return \p os
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const normal_distribution<RealType> &d);
+
+
+/*! This function streams a normal_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p normal_distribution to stream in.
+ *  \return \p is
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           normal_distribution<RealType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::normal_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/normal_distribution.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/subtract_with_carry_engine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/subtract_with_carry_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..69ee841fda32197f2adba1176b9548c25cffeade
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/subtract_with_carry_engine.h
@@ -0,0 +1,255 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file subtract_with_carry_engine.h
+ *  \brief A subtract-with-carry pseudorandom number generator
+ *         based on Marsaglia & Zaman.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/random/detail/random_core_access.h>
+
+#include <thrust/detail/cstdint.h>
+#include <cstddef> // for size_t
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_engine_templates
+ *  \{
+ */
+
+/*! \class subtract_with_carry_engine
+ *  \brief A \p subtract_with_carry_engine random number engine produces unsigned
+ *         integer random numbers using the subtract with carry algorithm of Marsaglia & Zaman.
+ *
+ *         The generation algorithm is performed as follows:
+ *         -# Let <tt>Y = X_{i-s}- X_{i-r} - c</tt>.
+ *         -# Set <tt>X_i</tt> to <tt>y = T mod m</tt>. Set \c c to \c 1 if <tt>Y < 0</tt>, otherwise set \c c to \c 0.
+ *
+ *         This algorithm corresponds to a modular linear function of the form
+ *
+ *         <tt>TA(x_i) = (a * x_i) mod b</tt>, where \c b is of the form <tt>m^r - m^s + 1</tt> and
+ *         <tt>a = b - (b-1)/m</tt>.
+ *
+ *  \tparam UIntType The type of unsigned integer to produce.
+ *  \tparam w The word size of the produced values (<tt> w <= sizeof(UIntType)</tt>).
+ *  \tparam s The short lag of the generation algorithm.
+ *  \tparam r The long lag of the generation algorithm.
+ *
+ *  \note Inexperienced users should not use this class template directly.  Instead, use
+ *  \p ranlux24_base or \p ranlux48_base, which are instances of \p subtract_with_carry_engine.
+ *
+ *  \see thrust::random::ranlux24_base
+ *  \see thrust::random::ranlux48_base
+ */
+template<typename UIntType, size_t w, size_t s, size_t r>
+  class subtract_with_carry_engine
+{
+    /*! \cond
+     */
+  private:
+    static const UIntType modulus = UIntType(1) << w;
+    /*! \endcond
+     */
+
+  public:
+    // types
+    
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p subtract_with_carry_engine.
+     */
+    typedef UIntType result_type;
+
+    // engine characteristics
+
+    /*! The word size of the produced values.
+     */
+    static const size_t word_size = w;
+
+    /*! The size of the short lag used in the generation algorithm.
+     */
+    static const size_t short_lag = s;
+
+    /*! The size of the long lag used in the generation algorithm.
+     */
+    static const size_t long_lag = r;
+
+    /*! The smallest value this \p subtract_with_carry_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p subtract_with_carry_engine may potentially produce.
+     */
+    static const result_type max = modulus - 1;
+
+    /*! The default seed of this \p subtract_with_carry_engine.
+     */
+    static const result_type default_seed = 19780503u;
+
+    // constructors and seeding functions
+
+    /*! This constructor, which optionally accepts a seed, initializes a new
+     *  \p subtract_with_carry_engine.
+     *  
+     *  \param value The seed used to intialize this \p subtract_with_carry_engine's state.
+     */
+    __host__ __device__
+    explicit subtract_with_carry_engine(result_type value = default_seed);
+
+    /*! This method initializes this \p subtract_with_carry_engine's state, and optionally accepts
+     *  a seed value.
+     *
+     *  \param value The seed used to initializes this \p subtract_with_carry_engine's state.
+     */
+    __host__ __device__
+    void seed(result_type value = default_seed);
+
+    // generating functions
+    
+    /*! This member function produces a new random value and updates this \p subtract_with_carry_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p subtract_with_carry_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    /*! \cond
+     */
+  private:
+    result_type m_x[long_lag];
+    unsigned int m_k;
+    int m_carry;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const subtract_with_carry_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    /*! \endcond
+     */
+}; // end subtract_with_carry_engine
+
+
+/*! This function checks two \p subtract_with_carry_engines for equality.
+ *  \param lhs The first \p subtract_with_carry_engine to test.
+ *  \param rhs The second \p subtract_with_carry_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_>
+__host__ __device__
+bool operator==(const subtract_with_carry_engine<UIntType_,w_,s_,r_> &lhs,
+                const subtract_with_carry_engine<UIntType_,w_,s_,r_> &rhs);
+
+
+/*! This function checks two \p subtract_with_carry_engines for inequality.
+ *  \param lhs The first \p subtract_with_carry_engine to test.
+ *  \param rhs The second \p subtract_with_carry_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_>
+__host__ __device__
+bool operator!=(const subtract_with_carry_engine<UIntType_,w_,s_,r_>&lhs,
+                const subtract_with_carry_engine<UIntType_,w_,s_,r_>&rhs);
+
+
+/*! This function streams a subtract_with_carry_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p subtract_with_carry_engine to stream out.
+ *  \return \p os
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const subtract_with_carry_engine<UIntType_,w_,s_,r_> &e);
+
+
+/*! This function streams a subtract_with_carry_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p subtract_with_carry_engine to stream in.
+ *  \return \p is
+ */
+template<typename UIntType_, size_t w_, size_t s_, size_t r_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           subtract_with_carry_engine<UIntType_,w_,s_,r_> &e);
+
+
+/*! \} // end random_number_engine_templates
+ */
+
+
+/*! \addtogroup predefined_random
+ *  \{
+ */
+
+// XXX N2111 uses uint_fast32_t here
+
+/*! \typedef ranlux24_base
+ *  \brief A random number engine with predefined parameters which implements the
+ *         base engine of the \p ranlux24 random number engine.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux24_base
+ *        shall produce the value \c 7937952 .
+ */
+typedef subtract_with_carry_engine<thrust::detail::uint32_t, 24, 10, 24> ranlux24_base;
+
+
+// XXX N2111 uses uint_fast64_t here
+
+/*! \typedef ranlux48_base
+ *  \brief A random number engine with predefined parameters which implements the
+ *         base engine of the \p ranlux48 random number engine.
+ *  \note The 10000th consecutive invocation of a default-constructed object of type \p ranlux48_base
+ *        shall produce the value \c 192113843633948 .
+ */
+typedef subtract_with_carry_engine<thrust::detail::uint64_t, 48,  5, 12> ranlux48_base;
+
+/*! \} // end predefined_random
+ */
+
+} // end random
+
+// import names into thrust::
+using random::subtract_with_carry_engine;
+using random::ranlux24_base;
+using random::ranlux48_base;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/subtract_with_carry_engine.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_int_distribution.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_int_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..18f369fc2a4a26b03c1798ac26c60f8a20e35c06
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_int_distribution.h
@@ -0,0 +1,276 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file uniform_int_distribution.h
+ *  \brief A uniform distribution of integer-valued numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/pair.h>
+#include <thrust/detail/integer_traits.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_distributions Random Number Distributions Class Templates
+ *  \ingroup random
+ *  \{
+ */
+
+/*! \class uniform_int_distribution
+ *  \brief A \p uniform_int_distribution random number distribution produces signed or unsigned integer
+ *         uniform random numbers from a given range.
+ *
+ *  \tparam IntType The type of integer to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p uniform_int_distribution with a 
+ *  random number engine to produce random integers drawn from a given range:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/uniform_int_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a uniform_int_distribution to produce ints from [-7,13]
+ *    thrust::uniform_int_distribution<int> dist(-7,13);
+ *
+ *    // write a random number from the range [-7,13] to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the range of the distribution, just in case we forgot
+ *    std::cout << dist.min() << std::endl;
+ *
+ *    // -7 is printed
+ *
+ *    std::cout << dist.max() << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    // write the parameters of the distribution (which happen to be the bounds) to standard output
+ *    std::cout << dist.a() << std::endl;
+ *
+ *    // -7 is printed
+ *
+ *    std::cout << dist.b() << std::endl;
+ *
+ *    // 13 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename IntType = int>
+  class uniform_int_distribution
+{
+  public:
+    // types
+
+    /*! \typedef result_type
+     *  \brief The type of the integer produced by this \p uniform_int_distribution.
+     */
+    typedef IntType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p uniform_int_distribution's parameters.
+     */
+    typedef thrust::pair<IntType,IntType> param_type;
+
+    // constructors and reset functions
+
+    /*! This constructor creates a new \p uniform_int_distribution from two values defining the
+     *  range of the distribution.
+     *  
+     *  \param a The smallest integer to potentially produce. Defaults to \c 0.
+     *  \param b The largest integer to potentially produce. Defaults to the largest representable integer in
+     *           the platform.
+     */
+    __host__ __device__
+    explicit uniform_int_distribution(IntType a = 0,
+                                      IntType b = THRUST_NS_QUALIFIER::detail::integer_traits<IntType>::const_max);
+
+    /*! This constructor creates a new \p uniform_int_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *  
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the range) of the distribution.
+     */
+    __host__ __device__
+    explicit uniform_int_distribution(const param_type &parm);
+
+    /*! This does nothing.  It is included to conform to the requirements of the RandomDistribution concept.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new uniform random integer drawn from this \p uniform_int_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new uniform random integer as if by creating a new \p uniform_int_distribution 
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p uniform_int_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+    
+    /*! This method returns the value of the parameter with which this \p uniform_int_distribution
+     *  was constructed.
+     *
+     *  \return The lower bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type a(void) const;
+
+    /*! This method returns the value of the parameter with which this \p uniform_int_distribution
+     *  was constructed.
+     *
+     *  \return The upper bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type b(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p uniform_int_distribution was constructed.
+     *
+     *  \return A \p param_type object enapsulating the range of this \p uniform_int_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p uniform_int_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new range of this \p uniform_int_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest integer this \p uniform_int_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the largest integer this \p uniform_int_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p uniform_int_distribution's range.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const uniform_int_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end uniform_int_distribution
+
+
+/*! This function checks two \p uniform_int_distributions for equality.
+ *  \param lhs The first \p uniform_int_distribution to test.
+ *  \param rhs The second \p uniform_int_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename IntType>
+__host__ __device__
+bool operator==(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs);
+
+
+/*! This function checks two \p uniform_int_distributions for inequality.
+ *  \param lhs The first \p uniform_int_distribution to test.
+ *  \param rhs The second \p uniform_int_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename IntType>
+__host__ __device__
+bool operator!=(const uniform_int_distribution<IntType> &lhs,
+                const uniform_int_distribution<IntType> &rhs);
+
+
+/*! This function streams a uniform_int_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p uniform_int_distribution to stream out.
+ *  \return \p os
+ */
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_int_distribution<IntType> &d);
+
+
+/*! This function streams a uniform_int_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p uniform_int_distribution to stream in.
+ *  \return \p is
+ */
+template<typename IntType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_int_distribution<IntType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::uniform_int_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/uniform_int_distribution.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_real_distribution.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_real_distribution.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6c5a7d88a59c8fe180d6b02efc7a130eb94a75a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/uniform_real_distribution.h
@@ -0,0 +1,273 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file uniform_real_distribution.h
+ *  \brief A uniform distribution of real-valued numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/pair.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+
+/*! \addtogroup random_number_distributions
+ *  \{
+ */
+
+/*! \class uniform_real_distribution
+ *  \brief A \p uniform_real_distribution random number distribution produces floating point
+ *         uniform random numbers from a half-open interval.
+ *
+ *  \tparam RealType The type of floating point number to produce.
+ *
+ *  The following code snippet demonstrates examples of using a \p uniform_real_distribution with a 
+ *  random number engine to produce random integers drawn from a given range:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/uniform_real_distribution.h>
+ *
+ *  int main(void)
+ *  {
+ *    // create a minstd_rand object to act as our source of randomness
+ *    thrust::minstd_rand rng;
+ *
+ *    // create a uniform_real_distribution to produce floats from [-7,13)
+ *    thrust::uniform_real_distribution<float> dist(-7,13);
+ *
+ *    // write a random number from the range [-7,13) to standard output
+ *    std::cout << dist(rng) << std::endl;
+ *
+ *    // write the range of the distribution, just in case we forgot
+ *    std::cout << dist.min() << std::endl;
+ *
+ *    // -7.0 is printed
+ *
+ *    std::cout << dist.max() << std::endl;
+ *
+ *    // 13.0 is printed
+ *
+ *    // write the parameters of the distribution (which happen to be the bounds) to standard output
+ *    std::cout << dist.a() << std::endl;
+ *
+ *    // -7.0 is printed
+ *
+ *    std::cout << dist.b() << std::endl;
+ *
+ *    // 13.0 is printed
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename RealType = double>
+  class uniform_real_distribution
+{
+  public:
+    // types
+    
+    /*! \typedef result_type
+     *  \brief The type of the floating point number produced by this \p uniform_real_distribution.
+     */
+    typedef RealType result_type;
+
+    /*! \typedef param_type
+     *  \brief The type of the object encapsulating this \p uniform_real_distribution's parameters.
+     */
+    typedef thrust::pair<RealType,RealType> param_type;
+
+    // constructors and reset functions
+    
+    /*! This constructor creates a new \p uniform_real_distribution from two values defining the
+     *  half-open interval of the distribution.
+     *  
+     *  \param a The smallest floating point number to potentially produce. Defaults to \c 0.0.
+     *  \param b The smallest number larger than the largest floating point number to potentially produce. Defaults to \c 1.0.
+     */
+    __host__ __device__
+    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
+
+    /*! This constructor creates a new \p uniform_real_distribution from a \p param_type object
+     *  encapsulating the range of the distribution.
+     *  
+     *  \param parm A \p param_type object encapsulating the parameters (i.e., the range) of the distribution.
+     */
+    __host__ __device__
+    explicit uniform_real_distribution(const param_type &parm);
+
+    /*! This does nothing.  It is included to conform to the requirements of the RandomDistribution concept.
+     */
+    __host__ __device__
+    void reset(void);
+
+    // generating functions
+
+    /*! This method produces a new uniform random integer drawn from this \p uniform_real_distribution's
+     *  range using a \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng);
+
+    /*! This method produces a new uniform random integer as if by creating a new \p uniform_real_distribution 
+     *  from the given \p param_type object, and calling its <tt>operator()</tt> method with the given
+     *  \p UniformRandomNumberGenerator as a source of randomness.
+     *
+     *  \param urng The \p UniformRandomNumberGenerator to use as a source of randomness.
+     *  \param parm A \p param_type object encapsulating the parameters of the \p uniform_real_distribution
+     *              to draw from.
+     */
+    template<typename UniformRandomNumberGenerator>
+    __host__ __device__
+    result_type operator()(UniformRandomNumberGenerator &urng, const param_type &parm);
+
+    // property functions
+
+    /*! This method returns the value of the parameter with which this \p uniform_real_distribution
+     *  was constructed.
+     *
+     *  \return The lower bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type a(void) const;
+
+    /*! This method returns the value of the parameter with which this \p uniform_real_distribution
+     *  was constructed.
+     *
+     *  \return The upper bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type b(void) const;
+
+    /*! This method returns a \p param_type object encapsulating the parameters with which this
+     *  \p uniform_real_distribution was constructed.
+     *
+     *  \return A \p param_type object enapsulating the half-open interval of this \p uniform_real_distribution.
+     */
+    __host__ __device__
+    param_type param(void) const;
+
+    /*! This method changes the parameters of this \p uniform_real_distribution using the values encapsulated
+     *  in a given \p param_type object.
+     *
+     *  \param parm A \p param_type object encapsulating the new half-open interval of this \p uniform_real_distribution.
+     */
+    __host__ __device__
+    void param(const param_type &parm);
+
+    /*! This method returns the smallest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The lower bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type min THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! This method returns the smallest number larger than largest floating point number this \p uniform_real_distribution can potentially produce.
+     *
+     *  \return The upper bound of this \p uniform_real_distribution's half-open interval.
+     */
+    __host__ __device__
+    result_type max THRUST_PREVENT_MACRO_SUBSTITUTION (void) const;
+
+    /*! \cond
+     */
+  private:
+    param_type m_param;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const uniform_real_distribution &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+    /*! \endcond
+     */
+}; // end uniform_real_distribution
+
+
+/*! This function checks two \p uniform_real_distributions for equality.
+ *  \param lhs The first \p uniform_real_distribution to test.
+ *  \param rhs The second \p uniform_real_distribution to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator==(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs);
+
+
+/*! This function checks two \p uniform_real_distributions for inequality.
+ *  \param lhs The first \p uniform_real_distribution to test.
+ *  \param rhs The second \p uniform_real_distribution to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename RealType>
+__host__ __device__
+bool operator!=(const uniform_real_distribution<RealType> &lhs,
+                const uniform_real_distribution<RealType> &rhs);
+
+
+/*! This function streams a uniform_real_distribution to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param d The \p uniform_real_distribution to stream out.
+ *  \return \p os
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const uniform_real_distribution<RealType> &d);
+
+
+/*! This function streams a uniform_real_distribution in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param d The \p uniform_real_distribution to stream in.
+ *  \return \p is
+ */
+template<typename RealType,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           uniform_real_distribution<RealType> &d);
+
+
+/*! \} // end random_number_distributions
+ */
+
+
+} // end random
+
+using random::uniform_real_distribution;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/uniform_real_distribution.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/xor_combine_engine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/xor_combine_engine.h
new file mode 100644
index 0000000000000000000000000000000000000000..321f040333d76a0683ffa5b77f8a59187113256d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/random/xor_combine_engine.h
@@ -0,0 +1,270 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file xor_combine_engine.h
+ *  \brief A pseudorandom number generator which produces pseudorandom
+ *         numbers from two integer base engines by merging their
+ *         pseudorandom numbers with bitwise exclusive-or.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/random/detail/xor_combine_engine_max.h>
+#include <thrust/random/detail/random_core_access.h>
+#include <iostream>
+#include <cstddef> // for size_t
+
+THRUST_NAMESPACE_BEGIN
+
+namespace random
+{
+
+/*! \addtogroup random_number_engine_adaptors
+ *  \{
+ */
+
+/*! \class xor_combine_engine
+ *  \brief An \p xor_combine_engine adapts two existing base random number engines and
+ *         produces random values by combining the values produced by each.
+ *
+ *  \tparam Engine1 The type of the first base random number engine to adapt.
+ *  \tparam s1 The size of the first shift to use in the generation algorithm.
+ *  \tparam Engine2 The type of the second base random number engine to adapt.
+ *  \tparam s2 The second of the second shift to use in the generation algorithm. Defaults to \c 0.
+ *
+ *  The following code snippet shows an example of using an \p xor_combine_engine instance:
+ *
+ *  \code
+ *  #include <thrust/random/linear_congruential_engine.h>
+ *  #include <thrust/random/xor_combine_engine.h>
+ *  #include <iostream>
+ *
+ *  int main(void)
+ *  {
+ *    // create an xor_combine_engine from minstd_rand and minstd_rand0
+ *    // use a shift of 0 for each
+ *    thrust::xor_combine_engine<thrust::minstd_rand,0,thrust::minstd_rand0,0> rng;
+ *
+ *    // print a random number to standard output
+ *    std::cout << rng() << std::endl;
+ *
+ *    return 0;
+ *  }
+ *  \endcode
+ */
+template<typename Engine1, size_t s1,
+         typename Engine2, size_t s2=0u>
+  class xor_combine_engine
+{
+  public:
+    // types
+
+    /*! \typedef base1_type
+     *  \brief The type of the first adapted base random number engine.
+     */
+    typedef Engine1 base1_type;
+
+    /*! \typedef base2_type
+     *  \brief The type of the second adapted base random number engine.
+     */
+    typedef Engine2 base2_type;
+
+    /*! \typedef result_type
+     *  \brief The type of the unsigned integer produced by this \p xor_combine_engine.
+     */
+    typedef typename thrust::detail::eval_if<
+      (sizeof(typename base2_type::result_type) > sizeof(typename base1_type::result_type)),
+      thrust::detail::identity_<typename base2_type::result_type>,
+      thrust::detail::identity_<typename base1_type::result_type>
+    >::type result_type;
+    
+    /*! The size of the first shift used in the generation algorithm.
+     */
+    static const size_t shift1 = s1;
+
+    /*! The size of the second shift used in the generation algorithm.
+     */
+    static const size_t shift2 = s2;
+
+    /*! The smallest value this \p xor_combine_engine may potentially produce.
+     */
+    static const result_type min = 0;
+
+    /*! The largest value this \p xor_combine_engine may potentially produce.
+     */
+    static const result_type max =
+      detail::xor_combine_engine_max<
+        Engine1, s1, Engine2, s2, result_type
+      >::value;
+
+    // constructors and seeding functions
+
+    /*! This constructor constructs a new \p xor_combine_engine and constructs
+     *  its adapted engines using their null constructors.
+     */
+    __host__ __device__
+    xor_combine_engine(void);
+
+    /*! This constructor constructs a new \p xor_combine_engine using
+     *  given \p base1_type and \p base2_type engines to initialize its adapted base engines.
+     *
+     *  \param urng1 A \p base1_type to use to initialize this \p xor_combine_engine's
+     *         first adapted base engine.
+     *  \param urng2 A \p base2_type to use to initialize this \p xor_combine_engine's
+     *         first adapted base engine.
+     */
+    __host__ __device__
+    xor_combine_engine(const base1_type &urng1, const base2_type &urng2);
+
+    /*! This constructor initializes a new \p xor_combine_engine with a given seed.
+     *  
+     *  \param s The seed used to intialize this \p xor_combine_engine's adapted base engines.
+     */
+    __host__ __device__
+    xor_combine_engine(result_type s);
+
+    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
+     *  by using their \p default_seed values.
+     */
+    __host__ __device__
+    void seed(void);
+
+    /*! This method initializes the state of this \p xor_combine_engine's adapted base engines
+     *  by using the given seed.
+     *
+     *  \param s The seed with which to intialize this \p xor_combine_engine's adapted base engines.
+     */
+    __host__ __device__
+    void seed(result_type s);
+
+    // generating functions
+
+    /*! This member function produces a new random value and updates this \p xor_combine_engine's state.
+     *  \return A new random number.
+     */
+    __host__ __device__
+    result_type operator()(void);
+
+    /*! This member function advances this \p xor_combine_engine's state a given number of times
+     *  and discards the results.
+     *
+     *  \param z The number of random values to discard.
+     *  \note This function is provided because an implementation may be able to accelerate it.
+     */
+    __host__ __device__
+    void discard(unsigned long long z);
+
+    // property functions
+
+    /*! This member function returns a const reference to this \p xor_combine_engine's
+     *  first adapted base engine.
+     *
+     *  \return A const reference to the first base engine this \p xor_combine_engine adapts.
+     */
+    __host__ __device__
+    const base1_type &base1(void) const;
+
+    /*! This member function returns a const reference to this \p xor_combine_engine's
+     *  second adapted base engine.
+     *
+     *  \return A const reference to the second base engine this \p xor_combine_engine adapts.
+     */
+    __host__ __device__
+    const base2_type &base2(void) const;
+
+    /*! \cond
+     */
+  private:
+    base1_type m_b1;
+    base2_type m_b2;
+
+    friend struct thrust::random::detail::random_core_access;
+
+    __host__ __device__
+    bool equal(const xor_combine_engine &rhs) const;
+
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT,Traits>& stream_in(std::basic_istream<CharT,Traits> &is);
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT,Traits>& stream_out(std::basic_ostream<CharT,Traits> &os) const;
+
+    /*! \endcond
+     */
+}; // end xor_combine_engine
+
+
+/*! This function checks two \p xor_combine_engines for equality.
+ *  \param lhs The first \p xor_combine_engine to test.
+ *  \param rhs The second \p xor_combine_engine to test.
+ *  \return \c true if \p lhs is equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
+__host__ __device__
+bool operator==(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
+                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
+
+
+/*! This function checks two \p xor_combine_engines for inequality.
+ *  \param lhs The first \p xor_combine_engine to test.
+ *  \param rhs The second \p xor_combine_engine to test.
+ *  \return \c true if \p lhs is not equal to \p rhs; \c false, otherwise.
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_>
+__host__ __device__
+bool operator!=(const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &lhs,
+                const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &rhs);
+
+
+/*! This function streams a xor_combine_engine to a \p std::basic_ostream.
+ *  \param os The \p basic_ostream to stream out to.
+ *  \param e The \p xor_combine_engine to stream out.
+ *  \return \p os
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
+         typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits> &os,
+           const xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
+
+
+/*! This function streams a xor_combine_engine in from a std::basic_istream.
+ *  \param is The \p basic_istream to stream from.
+ *  \param e The \p xor_combine_engine to stream in.
+ *  \return \p is
+ */
+template<typename Engine1_, size_t s1_, typename Engine2_, size_t s2_,
+         typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits> &is,
+           xor_combine_engine<Engine1_,s1_,Engine2_,s2_> &e);
+
+
+/*! \} // end random_number_engine_adaptors
+ */
+
+
+} // end random
+
+// import names into thrust::
+using random::xor_combine_engine;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/random/detail/xor_combine_engine.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..c7b378f7297e1278ecc36e761320a350a621b282
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reduce.h
@@ -0,0 +1,781 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/reduce.h
+ *  \brief Functions for reducing a range to a single value
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ */
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \c 0 as the initial value of the
+ *  reduction. \p reduce is similar to the C++ Standard Template Library's
+ *  <tt>std::accumulate</tt>. The primary difference between the two functions
+ *  is that <tt>std::accumulate</tt> guarantees the order of summation, while
+ *  \p reduce requires associativity of the binary operation to parallelize
+ *  the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case operator+) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \return The result of the reduction.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and if \c x and \c y are objects of \p InputIterator's \c value_type,
+ *          then <tt>x + y</tt> is defined and is convertible to \p InputIterator's
+ *          \c value_type. If \c T is \c InputIterator's \c value_type, then
+ *          <tt>T(0)</tt> is defined.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to compute
+ *  the sum of a sequence of integers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(thrust::host, data, data + 6);
+ *
+ *  // result == 9
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ */
+template<typename DerivedPolicy, typename InputIterator>
+__host__ __device__
+  typename thrust::iterator_traits<InputIterator>::value_type
+    reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last);
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \c 0 as the initial value of the
+ *  reduction. \p reduce is similar to the C++ Standard Template Library's
+ *  <tt>std::accumulate</tt>. The primary difference between the two functions
+ *  is that <tt>std::accumulate</tt> guarantees the order of summation, while
+ *  \p reduce requires associativity of the binary operation to parallelize
+ *  the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case operator+) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \return The result of the reduction.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and if \c x and \c y are objects of \p InputIterator's \c value_type,
+ *          then <tt>x + y</tt> is defined and is convertible to \p InputIterator's
+ *          \c value_type. If \c T is \c InputIterator's \c value_type, then
+ *          <tt>T(0)</tt> is defined.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to compute
+ *  the sum of a sequence of integers.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(data, data + 6);
+ *
+ *  // result == 9
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ */
+template<typename InputIterator> typename
+  thrust::iterator_traits<InputIterator>::value_type reduce(InputIterator first, InputIterator last);
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \p init as the initial value of the
+ *  reduction. \p reduce is similar to the C++ Standard Template Library's
+ *  <tt>std::accumulate</tt>. The primary difference between the two functions
+ *  is that <tt>std::accumulate</tt> guarantees the order of summation, while
+ *  \p reduce requires associativity of the binary operation to parallelize
+ *  the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case operator+) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param init The initial value.
+ *  \return The result of the reduction.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and if \c x and \c y are objects of \p InputIterator's \c value_type,
+ *          then <tt>x + y</tt> is defined and is convertible to \p T.
+ *  \tparam T is convertible to \p InputIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to compute
+ *  the sum of a sequence of integers including an intialization value using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(thrust::host, data, data + 6, 1);
+ *
+ *  // result == 10
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ */
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+  T reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+           InputIterator first,
+           InputIterator last,
+           T init);
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \p init as the initial value of the
+ *  reduction. \p reduce is similar to the C++ Standard Template Library's
+ *  <tt>std::accumulate</tt>. The primary difference between the two functions
+ *  is that <tt>std::accumulate</tt> guarantees the order of summation, while
+ *  \p reduce requires associativity of the binary operation to parallelize
+ *  the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case operator+) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param init The initial value.
+ *  \return The result of the reduction.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and if \c x and \c y are objects of \p InputIterator's \c value_type,
+ *          then <tt>x + y</tt> is defined and is convertible to \p T.
+ *  \tparam T is convertible to \p InputIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to compute
+ *  the sum of a sequence of integers including an intialization value.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(data, data + 6, 1);
+ *
+ *  // result == 10
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ */
+template<typename InputIterator, typename T>
+  T reduce(InputIterator first,
+           InputIterator last,
+           T init);
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \p init as the initial value of the
+ *  reduction and \p binary_op as the binary function used for summation. \p reduce
+ *  is similar to the C++ Standard Template Library's <tt>std::accumulate</tt>.
+ *  The primary difference between the two functions is that <tt>std::accumulate</tt>
+ *  guarantees the order of summation, while \p reduce requires associativity of
+ *  \p binary_op to parallelize the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case \p binary_op) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param init The initial value.
+ *  \param binary_op The binary function used to 'sum' values.
+ *  \return The result of the reduction.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \c InputIterator's \c value_type is convertible to \c T.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction's \c result_type is convertible to \p OutputType.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to
+ *  compute the maximum value of a sequence of integers using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(thrust::host,
+ *                              data, data + 6,
+ *                              -1,
+ *                              thrust::maximum<int>());
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ *  \see transform_reduce
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename T,
+         typename BinaryFunction>
+__host__ __device__
+  T reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+           InputIterator first,
+           InputIterator last,
+           T init,
+           BinaryFunction binary_op);
+
+
+/*! \p reduce is a generalization of summation: it computes the sum (or some
+ *  other binary operation) of all the elements in the range <tt>[first,
+ *  last)</tt>. This version of \p reduce uses \p init as the initial value of the
+ *  reduction and \p binary_op as the binary function used for summation. \p reduce
+ *  is similar to the C++ Standard Template Library's <tt>std::accumulate</tt>.
+ *  The primary difference between the two functions is that <tt>std::accumulate</tt>
+ *  guarantees the order of summation, while \p reduce requires associativity of
+ *  \p binary_op to parallelize the reduction.
+ *
+ *  Note that \p reduce also assumes that the binary reduction operator (in this
+ *  case \p binary_op) is commutative.  If the reduction operator is not commutative
+ *  then \p thrust::reduce should not be used.  Instead, one could use 
+ *  \p inclusive_scan (which does not require commutativity) and select the
+ *  last element of the output array.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param init The initial value.
+ *  \param binary_op The binary function used to 'sum' values.
+ *  \return The result of the reduction.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *          and \c InputIterator's \c value_type is convertible to \c T.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction's \c result_type is convertible to \p OutputType.
+ *
+ *  The following code snippet demonstrates how to use \p reduce to
+ *  compute the maximum value of a sequence of integers.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *  int result = thrust::reduce(data, data + 6,
+ *                              -1,
+ *                              thrust::maximum<int>());
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/accumulate
+ *  \see transform_reduce
+ */
+template<typename InputIterator,
+         typename T,
+         typename BinaryFunction>
+  T reduce(InputIterator first,
+           InputIterator last,
+           T init,
+           BinaryFunction binary_op);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c plus and the result copied to \c values_output. 
+ *
+ *  This version of \p reduce_by_key uses the function object \c equal_to
+ *  to test for equality and \c plus to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::reduce_by_key(thrust::host, A, A + N, B, C, D);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                InputIterator1 keys_first, 
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c plus and the result copied to \c values_output. 
+ *
+ *  This version of \p reduce_by_key uses the function object \c equal_to
+ *  to test for equality and \c plus to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::reduce_by_key(A, A + N, B, C, D);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first, 
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c plus and the result copied to \c values_output. 
+ *
+ *  This version of \p reduce_by_key uses the function object \c binary_pred
+ *  to test for equality and \c plus to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::reduce_by_key(thrust::host, A, A + N, B, C, D, binary_pred);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(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);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c plus and the result copied to \c values_output. 
+ *
+ *  This version of \p reduce_by_key uses the function object \c binary_pred
+ *  to test for equality and \c plus to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::reduce_by_key(A, A + N, B, C, D, binary_pred);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first, 
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output,
+                BinaryPredicate binary_pred);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c BinaryFunction \c binary_op and the result copied to \c values_output. 
+ *  Specifically, if consecutive key iterators \c i and \c (i + 1) are 
+ *  such that <tt>binary_pred(*i, *(i+1))</tt> is \c true, then the corresponding
+ *  values are reduced to a single value with \c binary_op.
+ *
+ *  This version of \p reduce_by_key uses the function object \c binary_pred
+ *  to test for equality and \c binary_op to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \param binary_op The binary function used to accumulate values.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *          and \c BinaryFunction's \c result_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int> binary_op;
+ *  new_end = thrust::reduce_by_key(thrust::host, A, A + N, B, C, D, binary_pred, binary_op);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(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,
+                BinaryFunction binary_op);
+
+
+/*! \p reduce_by_key is a generalization of \p reduce to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p reduce_by_key copies the first element of the group to the
+ *  \c keys_output. The corresponding values in the range are reduced using the
+ *  \c BinaryFunction \c binary_op and the result copied to \c values_output. 
+ *  Specifically, if consecutive key iterators \c i and \c (i + 1) are 
+ *  such that <tt>binary_pred(*i, *(i+1))</tt> is \c true, then the corresponding
+ *  values are reduced to a single value with \c binary_op.
+ *
+ *  This version of \p reduce_by_key uses the function object \c binary_pred
+ *  to test for equality and \c binary_op to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_output The beginning of the output key range.
+ *  \param values_output The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \param binary_op The binary function used to accumulate values.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_output, keys_output_last)</tt> and <tt>[values_output, values_output_last)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *          and \c BinaryFunction's \c result_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p reduce_by_key to
+ *  compact a sequence of key/value pairs and sum values with equal keys.
+ *
+ *  \code
+ *  #include <thrust/reduce.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int> binary_op;
+ *  new_end = thrust::reduce_by_key(A, A + N, B, C, D, binary_pred, binary_op);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 21, 9, 3} and new_end.second - D is 4.
+ *  \endcode
+ *  
+ *  \see reduce
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see unique_by_key_copy
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate,
+         typename BinaryFunction>
+  thrust::pair<OutputIterator1,OutputIterator2>
+  reduce_by_key(InputIterator1 keys_first, 
+                InputIterator1 keys_last,
+                InputIterator2 values_first,
+                OutputIterator1 keys_output,
+                OutputIterator2 values_output,
+                BinaryPredicate binary_pred,
+                BinaryFunction binary_op);
+
+
+/*! \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/reduce.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/remove.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/remove.h
new file mode 100644
index 0000000000000000000000000000000000000000..a57fcf211cf3739d9e1fceb478d9ec3e5c4a0881
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/remove.h
@@ -0,0 +1,802 @@
+/*
+ *  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 remove.h
+ *  \brief Functions for removing elements from a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup stream_compaction Stream Compaction
+ *  \ingroup reordering
+ *  \{
+ *
+ */
+
+
+/*! \p remove removes from the range <tt>[first, last)</tt> all elements that are
+ *  equal to \p value. That is, \p remove returns an iterator \p new_last such
+ *  that the range <tt>[first, new_last)</tt> contains no elements equal to
+ *  \p value. The iterators in the range <tt>[new_first,last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified. \p remove
+ *  is stable, meaning that the relative order of elements that are not equal to
+ *  \p value is unchanged.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param value The value to remove from the range <tt>[first, last)</tt>.
+ *         Elements which are equal to value are removed from the sequence.
+ *  \return A \p ForwardIterator pointing to the end of the resulting range of
+ *          elements which are not equal to \p value.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and objects of type \p T can be compared for equality with objects of \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p remove to remove a number
+ *  of interest from a range using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {3, 1, 4, 1, 5, 9};
+ *  int *new_end = thrust::remove(A, A + N, 1);
+ *  // The first four values of A are now {3, 4, 5, 9}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The meaning of "removal" is somewhat subtle. \p remove does not destroy any
+ *  iterators, and does not change the distance between \p first and \p last.
+ *  (There's no way that it could do anything of the sort.) So, for example, if
+ *  \c V is a device_vector, <tt>remove(V.begin(), V.end(), 0)</tt> does not
+ *  change <tt>V.size()</tt>: \c V will contain just as many elements as it did
+ *  before. \p remove returns an iterator that points to the end of the resulting
+ *  range after elements have been removed from it; it follows that the elements
+ *  after that iterator are of no interest, and may be discarded. If you are
+ *  removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a>, you may
+ *  simply erase them. That is, a reasonable way of removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a> is
+ *  <tt>S.erase(remove(S.begin(), S.end(), x), S.end())</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove_if
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename T>
+__host__ __device__
+  ForwardIterator remove(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         ForwardIterator first,
+                         ForwardIterator last,
+                         const T &value);
+
+
+/*! \p remove removes from the range <tt>[first, last)</tt> all elements that are
+ *  equal to \p value. That is, \p remove returns an iterator \p new_last such
+ *  that the range <tt>[first, new_last)</tt> contains no elements equal to
+ *  \p value. The iterators in the range <tt>[new_first,last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified. \p remove
+ *  is stable, meaning that the relative order of elements that are not equal to
+ *  \p value is unchanged.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param value The value to remove from the range <tt>[first, last)</tt>.
+ *         Elements which are equal to value are removed from the sequence.
+ *  \return A \p ForwardIterator pointing to the end of the resulting range of
+ *          elements which are not equal to \p value.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and objects of type \p T can be compared for equality with objects of \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p remove to remove a number
+ *  of interest from a range.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {3, 1, 4, 1, 5, 9};
+ *  int *new_end = thrust::remove(A, A + N, 1);
+ *  // The first four values of A are now {3, 4, 5, 9}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The meaning of "removal" is somewhat subtle. \p remove does not destroy any
+ *  iterators, and does not change the distance between \p first and \p last.
+ *  (There's no way that it could do anything of the sort.) So, for example, if
+ *  \c V is a device_vector, <tt>remove(V.begin(), V.end(), 0)</tt> does not
+ *  change <tt>V.size()</tt>: \c V will contain just as many elements as it did
+ *  before. \p remove returns an iterator that points to the end of the resulting
+ *  range after elements have been removed from it; it follows that the elements
+ *  after that iterator are of no interest, and may be discarded. If you are
+ *  removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a>, you may
+ *  simply erase them. That is, a reasonable way of removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a> is
+ *  <tt>S.erase(remove(S.begin(), S.end(), x), S.end())</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove_if
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename ForwardIterator,
+         typename T>
+  ForwardIterator remove(ForwardIterator first,
+                         ForwardIterator last,
+                         const T &value);
+
+
+/*! \p remove_copy copies elements that are not equal to \p value from the range
+ *  <tt>[first, last)</tt> to a range beginning at \p result. The return value is
+ *  the end of the resulting range. This operation is stable, meaning that the
+ *  relative order of the elements that are copied is the same as in
+ *  the range <tt>[first, last)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param value The value to omit from the copied range.
+ *  \return An OutputIterator pointing to the end of the resulting range of elements
+ *          which are not equal to \p value.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and objects of type \p T can be compared for equality with objects of \p InputIterator's \c value_type.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy to copy
+ *  a sequence of numbers to an output range while omitting a value of interest using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[N-2];
+ *  thrust::remove_copy(thrust::host, V, V + N, result, 0);
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, -1, 1, 2}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_if
+ *  \see remove_copy_if
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator remove_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             InputIterator first,
+                             InputIterator last,
+                             OutputIterator result,
+                             const T &value);
+
+
+/*! \p remove_copy copies elements that are not equal to \p value from the range
+ *  <tt>[first, last)</tt> to a range beginning at \p result. The return value is
+ *  the end of the resulting range. This operation is stable, meaning that the
+ *  relative order of the elements that are copied is the same as in
+ *  the range <tt>[first, last)</tt>.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param value The value to omit from the copied range.
+ *  \return An OutputIterator pointing to the end of the resulting range of elements
+ *          which are not equal to \p value.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          and objects of type \p T can be compared for equality with objects of \p InputIterator's \c value_type.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy to copy
+ *  a sequence of numbers to an output range while omitting a value of interest.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[N-2];
+ *  thrust::remove_copy(V, V + N, result, 0);
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, -1, 1, 2}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_if
+ *  \see remove_copy_if
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T>
+  OutputIterator remove_copy(InputIterator first,
+                             InputIterator last,
+                             OutputIterator result,
+                             const T &value);
+
+
+/*! \p remove_if removes from the range <tt>[first, last)</tt> every element \p x
+ *  such that <tt>pred(x)</tt> is \c true. That is, \p remove_if returns an
+ *  iterator \c new_last such that the range <tt>[first,new_last)</tt> contains
+ *  no elements for which \p pred is \c true. The iterators in the range
+ *  <tt>[new_last,last)</tt> are all still dereferenceable, but the elements that
+ *  they point to are unspecified. \p remove_if is stable, meaning that the
+ *  relative order of elements that are not removed is unchanged.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param pred A predicate to evaluate for each element of the range
+ *              <tt>[first,last)</tt>. Elements for which \p pred evaluates to
+ *              \c true are removed from the sequence.
+ *  \return A ForwardIterator pointing to the end of the resulting range of
+ *          elements for which \p pred evaluated to \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_if to remove
+ *  all even numbers from an array of integers using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  int *new_end = thrust::remove_if(thrust::host, A, A + N, is_even());
+ *  // The first three values of A are now {1, 5, 7}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The meaning of "removal" is somewhat subtle. \p remove_if does not
+ *  destroy any iterators, and does not change the distance between \p first and
+ *  \p last. (There's no way that it could do anything of the sort.) So, for
+ *  example, if \c V is a device_vector,
+ *  <tt>remove_if(V.begin(), V.end(), pred)</tt> does not change
+ *  <tt>V.size()</tt>: \c V will contain just as many elements as it did before.
+ *  \p remove_if returns an iterator that points to the end of the resulting
+ *  range after elements have been removed from it; it follows that the elements
+ *  after that iterator are of no interest, and may be discarded. If you are
+ *  removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a>, you may
+ *  simply erase them. That is, a reasonable way of removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a> is
+ *  <tt>S.erase(remove_if(S.begin(), S.end(), pred), S.end())</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator remove_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+/*! \p remove_if removes from the range <tt>[first, last)</tt> every element \p x
+ *  such that <tt>pred(x)</tt> is \c true. That is, \p remove_if returns an
+ *  iterator \c new_last such that the range <tt>[first,new_last)</tt> contains
+ *  no elements for which \p pred is \c true. The iterators in the range
+ *  <tt>[new_last,last)</tt> are all still dereferenceable, but the elements that
+ *  they point to are unspecified. \p remove_if is stable, meaning that the
+ *  relative order of elements that are not removed is unchanged.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param pred A predicate to evaluate for each element of the range
+ *              <tt>[first,last)</tt>. Elements for which \p pred evaluates to
+ *              \c true are removed from the sequence.
+ *  \return A ForwardIterator pointing to the end of the resulting range of
+ *          elements for which \p pred evaluated to \c true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_if to remove
+ *  all even numbers from an array of integers.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  int *new_end = thrust::remove_if(A, A + N, is_even());
+ *  // The first three values of A are now {1, 5, 7}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The meaning of "removal" is somewhat subtle. \p remove_if does not
+ *  destroy any iterators, and does not change the distance between \p first and
+ *  \p last. (There's no way that it could do anything of the sort.) So, for
+ *  example, if \c V is a device_vector,
+ *  <tt>remove_if(V.begin(), V.end(), pred)</tt> does not change
+ *  <tt>V.size()</tt>: \c V will contain just as many elements as it did before.
+ *  \p remove_if returns an iterator that points to the end of the resulting
+ *  range after elements have been removed from it; it follows that the elements
+ *  after that iterator are of no interest, and may be discarded. If you are
+ *  removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a>, you may
+ *  simply erase them. That is, a reasonable way of removing elements from a
+ *  <a href="https://en.cppreference.com/w/cpp/container">Sequence</a> is
+ *  <tt>S.erase(remove_if(S.begin(), S.end(), pred), S.end())</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator remove_if(ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+/*! \p remove_copy_if copies elements from the range <tt>[first,last)</tt> to a
+ *  range beginning at \p result, except that elements for which \p pred is
+ *  \c true are not copied. The return value is the end of the resulting range.
+ *  This operation is stable, meaning that the relative order of the elements that
+ *  are copied is the same as the range <tt>[first,last)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param pred A predicate to evaluate for each element of the range <tt>[first,last)</tt>.
+ *              Elements for which \p pred evaluates to \c false are not copied
+ *              to the resulting sequence.
+ *  \return An OutputIterator pointing to the end of the resulting range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy_if to copy
+ *  a sequence of numbers to an output range while omitting even numbers using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[2];
+ *  thrust::remove_copy_if(thrust::host, V, V + N, result, is_even());
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_if
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator remove_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+/*! \p remove_copy_if copies elements from the range <tt>[first,last)</tt> to a
+ *  range beginning at \p result, except that elements for which \p pred is
+ *  \c true are not copied. The return value is the end of the resulting range.
+ *  This operation is stable, meaning that the relative order of the elements that
+ *  are copied is the same as the range <tt>[first,last)</tt>.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param pred A predicate to evaluate for each element of the range <tt>[first,last)</tt>.
+ *              Elements for which \p pred evaluates to \c false are not copied
+ *              to the resulting sequence.
+ *  \return An OutputIterator pointing to the end of the resulting range.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy_if to copy
+ *  a sequence of numbers to an output range while omitting even numbers.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[2];
+ *  thrust::remove_copy_if(V, V + N, result, is_even());
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_if
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+/*! \p remove_if removes from the range <tt>[first, last)</tt> every element \p x
+ *  such that <tt>pred(x)</tt> is \c true. That is, \p remove_if returns an
+ *  iterator \c new_last such that the range <tt>[first, new_last)</tt> contains
+ *  no elements for which \p pred of the corresponding stencil value is \c true. 
+ *  The iterators in the range <tt>[new_last,last)</tt> are all still dereferenceable,
+ *  but the elements that they point to are unspecified. \p remove_if is stable,
+ *  meaning that the relative order of elements that are not removed is unchanged.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A predicate to evaluate for each element of the range
+ *              <tt>[stencil, stencil + (last - first))</tt>. Elements for which \p pred evaluates to
+ *              \c true are removed from the sequence <tt>[first, last)</tt>
+ *  \return A ForwardIterator pointing to the end of the resulting range of
+ *          elements for which \p pred evaluated to \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_if to remove
+ *  specific elements from an array of integers using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  int S[N] = {0, 1, 1, 1, 0, 0};
+ *
+ *  int *new_end = thrust::remove_if(thrust::host, A, A + N, S, thrust::identity<int>());
+ *  // The first three values of A are now {1, 5, 7}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The range <tt>[first, last)</tt> is not permitted to overlap with the range <tt>[stencil, stencil + (last - first))</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator remove_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+/*! \p remove_if removes from the range <tt>[first, last)</tt> every element \p x
+ *  such that <tt>pred(x)</tt> is \c true. That is, \p remove_if returns an
+ *  iterator \c new_last such that the range <tt>[first, new_last)</tt> contains
+ *  no elements for which \p pred of the corresponding stencil value is \c true. 
+ *  The iterators in the range <tt>[new_last,last)</tt> are all still dereferenceable,
+ *  but the elements that they point to are unspecified. \p remove_if is stable,
+ *  meaning that the relative order of elements that are not removed is unchanged.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred A predicate to evaluate for each element of the range
+ *              <tt>[stencil, stencil + (last - first))</tt>. Elements for which \p pred evaluates to
+ *              \c true are removed from the sequence <tt>[first, last)</tt>
+ *  \return A ForwardIterator pointing to the end of the resulting range of
+ *          elements for which \p pred evaluated to \c true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *  \pre The range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_if to remove
+ *  specific elements from an array of integers.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  int S[N] = {0, 1, 1, 1, 0, 0};
+ *
+ *  int *new_end = thrust::remove_if(A, A + N, S, thrust::identity<int>());
+ *  // The first three values of A are now {1, 5, 7}
+ *  // Values beyond new_end are unspecified
+ *  \endcode
+ *
+ *  \note The range <tt>[first, last)</tt> is not permitted to overlap with the range <tt>[stencil, stencil + (last - first))</tt>.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_copy_if
+ */
+template<typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator remove_if(ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+/*! \p remove_copy_if copies elements from the range <tt>[first,last)</tt> to a
+ *  range beginning at \p result, except that elements for which \p pred of the 
+ *  corresponding stencil value is \c true are not copied. The return value is 
+ *  the end of the resulting range.  This operation is stable, meaning that the
+ *  relative order of the elements that are copied is the same as the 
+ *  range <tt>[first,last)</tt>.
+ *
+ *  The algorithm's execution policy is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param pred A predicate to evaluate for each element of the range <tt>[first,last)</tt>.
+ *              Elements for which \p pred evaluates to \c false are not copied
+ *              to the resulting sequence.
+ *  \return An OutputIterator pointing to the end of the resulting range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy_if to copy
+ *  a sequence of numbers to an output range while omitting specific elements using the \p thrust::host
+ *  execution policy for parallelization.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int S[N] = { 1, 1,  0, 1, 0, 1};
+ *  int result[2];
+ *  thrust::remove_copy_if(thrust::host, V, V + N, S, result, thrust::identity<int>());
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_if
+ *  \see copy_if
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator remove_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator1 first,
+                                InputIterator1 last,
+                                InputIterator2 stencil,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+/*! \p remove_copy_if copies elements from the range <tt>[first,last)</tt> to a
+ *  range beginning at \p result, except that elements for which \p pred of the 
+ *  corresponding stencil value is \c true are not copied. The return value is 
+ *  the end of the resulting range.  This operation is stable, meaning that the
+ *  relative order of the elements that are copied is the same as the 
+ *  range <tt>[first,last)</tt>.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The resulting range is copied to the sequence beginning at this
+ *                location.
+ *  \param pred A predicate to evaluate for each element of the range <tt>[first,last)</tt>.
+ *              Elements for which \p pred evaluates to \c false are not copied
+ *              to the resulting sequence.
+ *  \return An OutputIterator pointing to the end of the resulting range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertible to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p remove_copy_if to copy
+ *  a sequence of numbers to an output range while omitting specific elements.
+ *
+ *  \code
+ *  #include <thrust/remove.h>
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int S[N] = { 1, 1,  0, 1, 0, 1};
+ *  int result[2];
+ *  thrust::remove_copy_if(V, V + N, S, result, thrust::identity<int>());
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-1, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/remove_copy
+ *  \see remove
+ *  \see remove_copy
+ *  \see remove_if
+ *  \see copy_if
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator remove_copy_if(InputIterator1 first,
+                                InputIterator1 last,
+                                InputIterator2 stencil,
+                                OutputIterator result,
+                                Predicate pred);
+
+
+/*! \} // end stream_compaction
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/remove.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/replace.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/replace.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5c0320c423a1254853394ae1b90023ac836a4c5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/replace.h
@@ -0,0 +1,819 @@
+/*
+ *  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 replace.h
+ *  \brief Functions for replacing elements in a range with a particular value
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \addtogroup replacing
+ *  \ingroup transformations
+ *  \{
+ */
+
+
+/*! \p replace replaces every element in the range [first, last) equal to \p old_value
+ *  with \p new_value. That is: for every iterator \c i, if <tt>*i == old_value</tt>
+ *  then it performs the <tt>assignment *i = new_value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param old_value The value to replace.
+ *  \param new_value The new value to replace \p old_value.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable>Assignable">Assignable</a>,
+ *          \p T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">EqualityComparable</a>,
+ *          objects of \p T may be compared for equality with objects of
+ *          \p ForwardIterator's \c value_type,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace to replace
+ *  a value of interest in a \c device_vector with another using the \p thrust::device
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] = 1;
+ *  A[1] = 2;
+ *  A[2] = 3;
+ *  A[3] = 1;
+ *
+ *  thrust::replace(thrust::device, A.begin(), A.end(), 1, 99);
+ *
+ *  // A contains [99, 2, 3, 99]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace_if
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void replace(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+               ForwardIterator first, ForwardIterator last,
+               const T &old_value,
+               const T &new_value);
+
+
+/*! \p replace replaces every element in the range [first, last) equal to \p old_value
+ *  with \p new_value. That is: for every iterator \c i, if <tt>*i == old_value</tt>
+ *  then it performs the <tt>assignment *i = new_value</tt>.
+ *
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param old_value The value to replace.
+ *  \param new_value The new value to replace \p old_value.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable>Assignable">Assignable</a>,
+ *          \p T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">EqualityComparable</a>,
+ *          objects of \p T may be compared for equality with objects of
+ *          \p ForwardIterator's \c value_type,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace to replace
+ *  a value of interest in a \c device_vector with another.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] = 1;
+ *  A[1] = 2;
+ *  A[2] = 3;
+ *  A[3] = 1;
+ *
+ *  thrust::replace(A.begin(), A.end(), 1, 99);
+ *
+ *  // A contains [99, 2, 3, 99]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace_if
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename ForwardIterator, typename T>
+  void replace(ForwardIterator first, ForwardIterator last, const T &old_value,
+               const T &new_value);
+
+
+/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
+ *  \p pred returns \c true with \p new_value. That is: for every iterator \c i, if
+ *  <tt>pred(*i)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
+ *         to \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace_if to replace
+ *  a \c device_vector's negative elements with \c 0 using the \p thrust::device execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  1;
+ *  A[1] = -3;
+ *  A[2] =  2;
+ *  A[3] = -1;
+ *
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_if(thrust::device, A.begin(), A.end(), pred, 0);
+ *
+ *  // A contains [1, 0, 2, 0]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename Predicate, typename T>
+__host__ __device__
+  void replace_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  ForwardIterator first, ForwardIterator last,
+                  Predicate pred,
+                  const T &new_value);
+
+
+/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
+ *  \p pred returns \c true with \p new_value. That is: for every iterator \c i, if
+ *  <tt>pred(*i)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
+ *
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
+ *         to \c true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace_if to replace
+ *  a \c device_vector's negative elements with \c 0.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  1;
+ *  A[1] = -3;
+ *  A[2] =  2;
+ *  A[3] = -1;
+ *
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_if(A.begin(), A.end(), pred, 0);
+ *
+ *  // A contains [1, 0, 2, 0]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename ForwardIterator, typename Predicate, typename T>
+  void replace_if(ForwardIterator first, ForwardIterator last,
+                  Predicate pred,
+                  const T &new_value);
+
+
+/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
+ *  <tt>pred(*s)</tt> returns \c true with \p new_value. That is: for every iterator
+ *  \c i in the range <tt>[first, last)</tt>, and \c s in the range <tt>[stencil, stencil + (last - first))</tt>,
+ *  if <tt>pred(*s)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
+ *         to \c true.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace_if to replace
+ *  a \c device_vector's element with \c 0 when its corresponding stencil element is less than zero
+ *  using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  10;
+ *  A[1] =  20;
+ *  A[2] =  30;
+ *  A[3] =  40;
+ *
+ *  thrust::device_vector<int> S(4);
+ *  S[0] = -1;
+ *  S[1] =  0;
+ *  S[2] = -1;
+ *  S[3] =  0;
+ *
+ *  is_less_than_zero pred;
+ *  thrust::replace_if(thrust::device, A.begin(), A.end(), S.begin(), pred, 0);
+ *
+ *  // A contains [0, 20, 0, 40]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename Predicate, typename T>
+__host__ __device__
+  void replace_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  ForwardIterator first, ForwardIterator last,
+                  InputIterator stencil,
+                  Predicate pred,
+                  const T &new_value);
+
+
+/*! \p replace_if replaces every element in the range <tt>[first, last)</tt> for which
+ *  <tt>pred(*s)</tt> returns \c true with \p new_value. That is: for every iterator
+ *  \c i in the range <tt>[first, last)</tt>, and \c s in the range <tt>[stencil, stencil + (last - first))</tt>,
+ *  if <tt>pred(*s)</tt> is \c true then it performs the assignment <tt>*i = new_value</tt>.
+ *
+ *  \param first The beginning of the sequence of interest.
+ *  \param last The end of the sequence of interest.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The new value to replace elements which <tt>pred(*i)</tt> evaluates
+ *         to \c true.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p replace_if to replace
+ *  a \c device_vector's element with \c 0 when its corresponding stencil element is less than zero.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  10;
+ *  A[1] =  20;
+ *  A[2] =  30;
+ *  A[3] =  40;
+ *
+ *  thrust::device_vector<int> S(4);
+ *  S[0] = -1;
+ *  S[1] =  0;
+ *  S[2] = -1;
+ *  S[3] =  0;
+ *
+ *  is_less_than_zero pred;
+ *  thrust::replace_if(A.begin(), A.end(), S.begin(), pred, 0);
+ *
+ *  // A contains [0, 20, 0, 40]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace
+ *  \see \c replace
+ *  \see \c replace_copy
+ *  \see \c replace_copy_if
+ */
+template<typename ForwardIterator, typename InputIterator, typename Predicate, typename T>
+  void replace_if(ForwardIterator first, ForwardIterator last,
+                  InputIterator stencil,
+                  Predicate pred,
+                  const T &new_value);
+
+
+/*! \p replace_copy copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element equal to \p old_value
+ *  is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>, \p replace_copy
+ *  performs the assignment <tt>*(result+n) = new_value</tt> if <tt>*(first+n) == old_value</tt>,
+ *  and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param old_value The value to replace.
+ *  \param new_value The replacement value for which <tt>*i == old_value</tt> evaluates to \c true.
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          \p T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          \p T may be compared for equality with \p InputIterator's \c value_type,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> A(4);
+ *  A[0] = 1;
+ *  A[1] = 2;
+ *  A[2] = 3;
+ *  A[3] = 1;
+ *
+ *  thrust::device_vector<int> B(4);
+ *
+ *  thrust::replace_copy(thrust::device, A.begin(), A.end(), B.begin(), 1, 99);
+ *
+ *  // B contains [99, 2, 3, 99]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace_copy
+ *  \see \c copy
+ *  \see \c replace
+ *  \see \c replace_if
+ *  \see \c replace_copy_if
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename T>
+__host__ __device__
+  OutputIterator replace_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator first, InputIterator last,
+                              OutputIterator result,
+                              const T &old_value,
+                              const T &new_value);
+
+
+/*! \p replace_copy copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element equal to \p old_value
+ *  is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>, \p replace_copy
+ *  performs the assignment <tt>*(result+n) = new_value</tt> if <tt>*(first+n) == old_value</tt>,
+ *  and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param old_value The value to replace.
+ *  \param new_value The replacement value for which <tt>*i == old_value</tt> evaluates to \c true.
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          \p T is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>,
+ *          \p T may be compared for equality with \p InputIterator's \c value_type,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> A(4);
+ *  A[0] = 1;
+ *  A[1] = 2;
+ *  A[2] = 3;
+ *  A[3] = 1;
+ *
+ *  thrust::device_vector<int> B(4);
+ *
+ *  thrust::replace_copy(A.begin(), A.end(), B.begin(), 1, 99);
+ *
+ *  // B contains [99, 2, 3, 99]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace_copy
+ *  \see \c copy
+ *  \see \c replace
+ *  \see \c replace_if
+ *  \see \c replace_copy_if
+ */
+template<typename InputIterator, typename OutputIterator, typename T>
+  OutputIterator replace_copy(InputIterator first, InputIterator last,
+                              OutputIterator result, const T &old_value,
+                              const T &new_value);
+
+
+/*! \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element for which \p pred
+ *  is \c true is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that 0 <= n < last-first,
+ *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
+ *  <tt>pred(*(first+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The replacement value to assign <tt>pred(*i)</tt> evaluates to \c true.
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  1;
+ *  A[1] = -3;
+ *  A[2] =  2;
+ *  A[3] = -1;
+ 
+ *  thrust::device_vector<int> B(4);
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_copy_if(thrust::device, A.begin(), A.end(), B.begin(), pred, 0);
+ *
+ *  // B contains [1, 0, 2, 0]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace_copy
+ *  \see \c replace
+ *  \see \c replace_if
+ *  \see \c replace_copy
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate, typename T>
+__host__ __device__
+  OutputIterator replace_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                 InputIterator first, InputIterator last,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value);
+
+
+/*! \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element for which \p pred
+ *  is \c true is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that 0 <= n < last-first,
+ *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
+ *  <tt>pred(*(first+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param pred The predicate to test on every value of the range <tt>[first,last)</tt>.
+ *  \param new_value The replacement value to assign <tt>pred(*i)</tt> evaluates to \c true.
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  1;
+ *  A[1] = -3;
+ *  A[2] =  2;
+ *  A[3] = -1;
+ 
+ *  thrust::device_vector<int> B(4);
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_copy_if(A.begin(), A.end(), B.begin(), pred, 0);
+ *
+ *  // B contains [1, 0, 2, 0]
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/replace_copy
+ *  \see \c replace
+ *  \see \c replace_if
+ *  \see \c replace_copy
+ */
+template<typename InputIterator, typename OutputIterator, typename Predicate, typename T>
+  OutputIterator replace_copy_if(InputIterator first, InputIterator last,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value);
+
+
+/*! This version of \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c true is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
+ *  <tt>pred(*(stencil+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last - first))</tt>.
+ *  \param new_value The replacement value to assign when <tt>pred(*s)</tt> evaluates to \c true. 
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *  \pre \p stencil may equal \p result, but the ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  10;
+ *  A[1] =  20;
+ *  A[2] =  30;
+ *  A[3] =  40;
+ *
+ *  thrust::device_vector<int> S(4);
+ *  S[0] = -1;
+ *  S[1] =  0;
+ *  S[2] = -1;
+ *  S[3] =  0;
+ *
+ *  thrust::device_vector<int> B(4);
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_if(thrust::device, A.begin(), A.end(), S.begin(), B.begin(), pred, 0);
+ *
+ *  // B contains [0, 20, 0, 40]
+ *  \endcode
+ *
+ *  \see \c replace_copy
+ *  \see \c replace_if
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename T>
+__host__ __device__
+  OutputIterator replace_copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                 InputIterator1 first, InputIterator1 last,
+                                 InputIterator2 stencil,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value);
+
+
+/*! This version of \p replace_copy_if copies elements from the range <tt>[first, last)</tt> to the range
+ *  <tt>[result, result + (last-first))</tt>, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c true is not copied; \p new_value is copied instead.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p replace_copy_if performs the assignment <tt>*(result+n) = new_value</tt> if
+ *  <tt>pred(*(stencil+n))</tt>, and <tt>*(result+n) = *(first+n)</tt> otherwise.
+ *
+ *  \param first The beginning of the sequence to copy from.
+ *  \param last The end of the sequence to copy from.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence to copy to.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last - first))</tt>.
+ *  \param new_value The replacement value to assign when <tt>pred(*s)</tt> evaluates to \c true. 
+ *  \return <tt>result + (last-first)</tt>
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *  \pre \p stencil may equal \p result, but the ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  \code
+ *  #include <thrust/replace.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  struct is_less_than_zero
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x < 0;
+ *    }
+ *  };
+ *  
+ *  ...
+ *  
+ *  thrust::device_vector<int> A(4);
+ *  A[0] =  10;
+ *  A[1] =  20;
+ *  A[2] =  30;
+ *  A[3] =  40;
+ *
+ *  thrust::device_vector<int> S(4);
+ *  S[0] = -1;
+ *  S[1] =  0;
+ *  S[2] = -1;
+ *  S[3] =  0;
+ *
+ *  thrust::device_vector<int> B(4);
+ *  is_less_than_zero pred;
+ *
+ *  thrust::replace_if(A.begin(), A.end(), S.begin(), B.begin(), pred, 0);
+ *
+ *  // B contains [0, 20, 0, 40]
+ *  \endcode
+ *
+ *  \see \c replace_copy
+ *  \see \c replace_if
+ */
+template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate, typename T>
+  OutputIterator replace_copy_if(InputIterator1 first, InputIterator1 last,
+                                 InputIterator2 stencil,
+                                 OutputIterator result,
+                                 Predicate pred,
+                                 const T &new_value);
+
+
+/*! \} // end replacing
+ *  \} // transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/replace.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reverse.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reverse.h
new file mode 100644
index 0000000000000000000000000000000000000000..056be200adcaea6d0e5deed224a452b26d1fa8c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/reverse.h
@@ -0,0 +1,211 @@
+/*
+ *  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 reverse.h
+ *  \brief Reverses the order of a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reordering
+ *  \ingroup algorithms
+ */
+
+
+/*! \p reverse reverses a range. That is: for every <tt>i</tt> such that
+ *  <tt>0 <= i <= (last - first) / 2</tt>, it exchanges <tt>*(first + i)</tt>
+ *  and <tt>*(last - (i + 1))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to reverse.
+ *  \param last The end of the range to reverse.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam BidirectionalIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/bidirectional_iterator">Bidirectional Iterator</a> and
+ *          \p BidirectionalIterator is mutable.
+ *
+ *  The following code snippet demonstrates how to use \p reverse to reverse a
+ *  \p device_vector of integers using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/reverse.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int data[N] = {0, 1, 2, 3, 4, 5};
+ *  thrust::device_vector<int> v(data, data + N);
+ *  thrust::reverse(thrust::device, v.begin(), v.end());
+ *  // v is now {5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/reverse
+ *  \see \p reverse_copy
+ *  \see \p reverse_iterator
+ */
+template<typename DerivedPolicy, typename BidirectionalIterator>
+__host__ __device__
+  void reverse(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+               BidirectionalIterator first,
+               BidirectionalIterator last);
+
+
+/*! \p reverse reverses a range. That is: for every <tt>i</tt> such that
+ *  <tt>0 <= i <= (last - first) / 2</tt>, it exchanges <tt>*(first + i)</tt>
+ *  and <tt>*(last - (i + 1))</tt>.
+ *
+ *  \param first The beginning of the range to reverse.
+ *  \param last The end of the range to reverse.
+ *
+ *  \tparam BidirectionalIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/bidirectional_iterator">Bidirectional Iterator</a> and
+ *          \p BidirectionalIterator is mutable.
+ *
+ *  The following code snippet demonstrates how to use \p reverse to reverse a
+ *  \p device_vector of integers.
+ *
+ *  \code
+ *  #include <thrust/reverse.h>
+ *  ...
+ *  const int N = 6;
+ *  int data[N] = {0, 1, 2, 3, 4, 5};
+ *  thrust::device_vector<int> v(data, data + N);
+ *  thrust::reverse(v.begin(), v.end());
+ *  // v is now {5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/reverse
+ *  \see \p reverse_copy
+ *  \see \p reverse_iterator
+ */
+template<typename BidirectionalIterator>
+  void reverse(BidirectionalIterator first,
+               BidirectionalIterator last);
+
+
+/*! \p reverse_copy differs from \p reverse only in that the reversed range
+ *  is written to a different output range, rather than inplace.
+ *
+ *  \p reverse_copy copies elements from the range <tt>[first, last)</tt> to the
+ *  range <tt>[result, result + (last - first))</tt> such that the copy is a 
+ *  reverse of the original range. Specifically: for every <tt>i</tt> such that
+ *  <tt>0 <= i < (last - first)</tt>, \p reverse_copy performs the assignment
+ *  <tt>*(result + (last - first) - i) = *(first + i)</tt>.
+ *
+ *  The return value is <tt>result + (last - first))</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to reverse.
+ *  \param last The end of the range to reverse.
+ *  \param result The beginning of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam BidirectionalIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/bidirectional_iterator">Bidirectional Iterator</a>,
+ *          and \p BidirectionalIterator's \p value_type is convertible to \p OutputIterator's \p value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p reverse_copy to reverse
+ *  an input \p device_vector of integers to an output \p device_vector using the \p thrust::device
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/reverse.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int data[N] = {0, 1, 2, 3, 4, 5};
+ *  thrust::device_vector<int> input(data, data + N);
+ *  thrust::device_vector<int> output(N);
+ *  thrust::reverse_copy(thrust::device, v.begin(), v.end(), output.begin());
+ *  // input is still {0, 1, 2, 3, 4, 5}
+ *  // output is now  {5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/reverse_copy
+ *  \see \p reverse
+ *  \see \p reverse_iterator
+ */
+template<typename DerivedPolicy, typename BidirectionalIterator, typename OutputIterator>
+__host__ __device__
+  OutputIterator reverse_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              BidirectionalIterator first,
+                              BidirectionalIterator last,
+                              OutputIterator result);
+
+
+/*! \p reverse_copy differs from \p reverse only in that the reversed range
+ *  is written to a different output range, rather than inplace.
+ *
+ *  \p reverse_copy copies elements from the range <tt>[first, last)</tt> to the
+ *  range <tt>[result, result + (last - first))</tt> such that the copy is a 
+ *  reverse of the original range. Specifically: for every <tt>i</tt> such that
+ *  <tt>0 <= i < (last - first)</tt>, \p reverse_copy performs the assignment
+ *  <tt>*(result + (last - first) - i) = *(first + i)</tt>.
+ *
+ *  The return value is <tt>result + (last - first))</tt>.
+ *
+ *  \param first The beginning of the range to reverse.
+ *  \param last The end of the range to reverse.
+ *  \param result The beginning of the output range.
+ *
+ *  \tparam BidirectionalIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/bidirectional_iterator">Bidirectional Iterator</a>,
+ *          and \p BidirectionalIterator's \p value_type is convertible to \p OutputIterator's \p value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p reverse_copy to reverse
+ *  an input \p device_vector of integers to an output \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/reverse.h>
+ *  ...
+ *  const int N = 6;
+ *  int data[N] = {0, 1, 2, 3, 4, 5};
+ *  thrust::device_vector<int> input(data, data + N);
+ *  thrust::device_vector<int> output(N);
+ *  thrust::reverse_copy(v.begin(), v.end(), output.begin());
+ *  // input is still {0, 1, 2, 3, 4, 5}
+ *  // output is now  {5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/reverse_copy
+ *  \see \p reverse
+ *  \see \p reverse_iterator
+ */
+template<typename BidirectionalIterator, typename OutputIterator>
+  OutputIterator reverse_copy(BidirectionalIterator first,
+                              BidirectionalIterator last,
+                              OutputIterator result);
+
+
+/*! \} // end reordering
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/reverse.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b381422323f203b2995335089c0c8a5910cdbb2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scan.h
@@ -0,0 +1,1656 @@
+/*
+ *  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 scan.h
+ *  \brief Functions for computing prefix sums
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+
+/*! \addtogroup prefixsums Prefix Sums
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p inclusive_scan computes an inclusive prefix sum operation. The
+ *  term 'inclusive' means that each result includes the corresponding
+ *  input operand in the partial sum. More precisely, <tt>*first</tt> is 
+ *  assigned to <tt>*result</tt> and the sum of <tt>*first</tt> and 
+ *  <tt>*(first + 1)</tt> is assigned to <tt>*(result + 1)</tt>, and so on. 
+ *  This version of \p inclusive_scan assumes plus as the associative operator.  
+ *  When the input and output sequences are the same, the scan is performed 
+ *  in-place.
+ *
+ *  \p inclusive_scan is similar to \c std::partial_sum in the STL.  The primary
+ *  difference between the two functions is that \c std::partial_sum guarantees
+ *  a serial summation order, while \p inclusive_scan requires associativity of 
+ *  the binary operation to parallelize the prefix sum.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined. If \c T is
+ *                         \c OutputIterator's \c value_type, then <tt>T(0)</tt> is
+ *                         defined.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place
+ *  prefix sum using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::inclusive_scan(thrust::host, data, data + 6, data); // in-place scan
+ *
+ *  // data is now {1, 1, 3, 5, 6, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result);
+
+
+/*! \p inclusive_scan computes an inclusive prefix sum operation. The
+ *  term 'inclusive' means that each result includes the corresponding
+ *  input operand in the partial sum. More precisely, <tt>*first</tt> is 
+ *  assigned to <tt>*result</tt> and the sum of <tt>*first</tt> and 
+ *  <tt>*(first + 1)</tt> is assigned to <tt>*(result + 1)</tt>, and so on. 
+ *  This version of \p inclusive_scan assumes plus as the associative operator.  
+ *  When the input and output sequences are the same, the scan is performed 
+ *  in-place.
+ *
+ *  \p inclusive_scan is similar to \c std::partial_sum in the STL.  The primary
+ *  difference between the two functions is that \c std::partial_sum guarantees
+ *  a serial summation order, while \p inclusive_scan requires associativity of 
+ *  the binary operation to parallelize the prefix sum.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined. If \c T is
+ *                         \c OutputIterator's \c value_type, then <tt>T(0)</tt> is
+ *                         defined.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::inclusive_scan(data, data + 6, data); // in-place scan
+ *
+ *  // data is now {1, 1, 3, 5, 6, 9}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ *
+ */
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator inclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result);
+
+
+/*! \p inclusive_scan computes an inclusive prefix sum operation. The
+ *  term 'inclusive' means that each result includes the corresponding
+ *  input operand in the partial sum.  When the input and output sequences 
+ *  are the same, the scan is performed in-place.
+ *
+ *  \p inclusive_scan is similar to \c std::partial_sum in the STL.  The primary
+ *  difference between the two functions is that \c std::partial_sum guarantees
+ *  a serial summation order, while \p inclusive_scan requires associativity of 
+ *  the binary operation to parallelize the prefix sum.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>
+ *                         and \c OutputIterator's \c value_type is convertible to
+ *                         both \c AssociativeOperator's \c first_argument_type and
+ *                         \c second_argument_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan to compute an in-place
+ *  prefix sum using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::maximum<int> binary_op;
+ *
+ *  thrust::inclusive_scan(thrust::host, data, data + 10, data, binary_op); // in-place scan
+ *
+ *  // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                AssociativeOperator binary_op);
+
+
+/*! \p inclusive_scan computes an inclusive prefix sum operation. The
+ *  term 'inclusive' means that each result includes the corresponding
+ *  input operand in the partial sum.  When the input and output sequences 
+ *  are the same, the scan is performed in-place.
+ *    
+ *  \p inclusive_scan is similar to \c std::partial_sum in the STL.  The primary
+ *  difference between the two functions is that \c std::partial_sum guarantees
+ *  a serial summation order, while \p inclusive_scan requires associativity of 
+ *  the binary operation to parallelize the prefix sum.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>
+ *                         and \c OutputIterator's \c value_type is convertible to
+ *                         both \c AssociativeOperator's \c first_argument_type and
+ *                         \c second_argument_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan
+ *
+ *  \code
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::maximum<int> binary_op;
+ *
+ *  thrust::inclusive_scan(data, data + 10, data, binary_op); // in-place scan
+ *
+ *  // data is now {-5, 0, 2, 2, 2, 4, 4, 4, 4, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename AssociativeOperator>
+  OutputIterator inclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                AssociativeOperator binary_op);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  <tt>0</tt> is assigned to <tt>*result</tt> and the sum of 
+ *  <tt>0</tt> and <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>,
+ *  and so on. This version of \p exclusive_scan assumes plus as the 
+ *  associative operator and \c 0 as the initial value.  When the input and 
+ *  output sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined. If \c T is
+ *                         \c OutputIterator's \c value_type, then <tt>T(0)</tt> is
+ *                         defined.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
+ *  prefix sum using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::exclusive_scan(thrust::host, data, data + 6, data); // in-place scan
+ *
+ *  // data is now {0, 1, 1, 3, 5, 6}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  <tt>0</tt> is assigned to <tt>*result</tt> and the sum of 
+ *  <tt>0</tt> and <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>,
+ *  and so on. This version of \p exclusive_scan assumes plus as the 
+ *  associative operator and \c 0 as the initial value.  When the input and 
+ *  output sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined. If \c T is
+ *                         \c OutputIterator's \c value_type, then <tt>T(0)</tt> is
+ *                         defined.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::exclusive_scan(data, data + 6, data); // in-place scan
+ *
+ *  // data is now {0, 1, 1, 3, 5, 6}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  \p init is assigned to <tt>*result</tt> and the sum of \p init and 
+ *  <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, and so on. 
+ *  This version of \p exclusive_scan assumes plus as the associative 
+ *  operator but requires an initial value \p init.  When the input and 
+ *  output sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param init The initial value.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
+ *  prefix sum using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::exclusive_scan(thrust::host, data, data + 6, data, 4); // in-place scan
+ *
+ *  // data is now {4, 5, 5, 7, 9, 10}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  \p init is assigned to <tt>*result</tt> and the sum of \p init and 
+ *  <tt>*first</tt> is assigned to <tt>*(result + 1)</tt>, and so on. 
+ *  This version of \p exclusive_scan assumes plus as the associative 
+ *  operator but requires an initial value \p init.  When the input and 
+ *  output sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param init The initial value.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's
+ *                         \c value_type, then <tt>x + y</tt> is defined.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::exclusive_scan(data, data + 6, data, 4); // in-place scan
+ *
+ *  // data is now {4, 5, 5, 7, 9, 10}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  \p init is assigned to <tt>\*result</tt> and the value
+ *  <tt>binary_op(init, \*first)</tt> is assigned to <tt>\*(result + 1)</tt>,
+ *  and so on. This version of the function requires both an associative 
+ *  operator and an initial value \p init.  When the input and output
+ *  sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param init The initial value.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>
+ *                         and \c OutputIterator's \c value_type is convertible to
+ *                         both \c AssociativeOperator's \c first_argument_type and
+ *                         \c second_argument_type.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan to compute an in-place
+ *  prefix sum using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::maximum<int> binary_op;
+ *
+ *  thrust::exclusive_scan(thrust::host, data, data + 10, data, 1, binary_op); // in-place scan
+ *
+ *  // data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init,
+                                AssociativeOperator binary_op);
+
+
+/*! \p exclusive_scan computes an exclusive prefix sum operation. The
+ *  term 'exclusive' means that each result does not include the 
+ *  corresponding input operand in the partial sum.  More precisely,
+ *  \p init is assigned to <tt>\*result</tt> and the value
+ *  <tt>binary_op(init, \*first)</tt> is assigned to <tt>\*(result + 1)</tt>,
+ *  and so on. This version of the function requires both an associative 
+ *  operator and an initial value \p init.  When the input and output
+ *  sequences are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param init The initial value.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to
+ *                        \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>
+ *                         and \c OutputIterator's \c value_type is convertible to
+ *                         both \c AssociativeOperator's \c first_argument_type and
+ *                         \c second_argument_type.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::maximum<int> binary_op;
+ *
+ *  thrust::exclusive_scan(data, data + 10, data, 1, binary_op); // in-place scan
+ *
+ *  // data is now {1, 1, 1, 2, 2, 2, 4, 4, 4, 4 }
+ *  \endcode
+ *  
+ *  \see https://en.cppreference.com/w/cpp/algorithm/partial_sum
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename AssociativeOperator>
+  OutputIterator exclusive_scan(InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init,
+                                AssociativeOperator binary_op);
+
+
+/*! \addtogroup segmentedprefixsums Segmented Prefix Sums
+ *  \ingroup prefixsums
+ *  \{
+ */
+
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c equal_to as the binary
+ *  predicate used to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to
+ *  different segments otherwise.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result);
+ 
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c equal_to as the binary
+ *  predicate used to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to
+ *  different segments otherwise.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::inclusive_scan_by_key(keys, keys + 10, data, data); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result);
+
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key uses the binary predicate 
+ *  \c pred to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to 
+ *  different segments otherwise.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec. 
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param binary_pred  The binary predicate used to determine equality of keys.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *
+ *  thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data, binary_pred); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred);
+
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key uses the binary predicate 
+ *  \c pred to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to 
+ *  different segments otherwise.
+ *
+ *  This version of \p inclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param binary_pred  The binary predicate used to determine equality of keys.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *
+ *  thrust::inclusive_scan_by_key(keys, keys + 10, data, data, binary_pred); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred);
+
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key uses the binary predicate 
+ *  \c pred to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to 
+ *  different segments otherwise.
+ *
+ *  This version of \p inclusive_scan_by_key uses the associative operator 
+ *  \c binary_op to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param binary_pred  The binary predicate used to determine equality of keys.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int>     binary_op;
+ *
+ *  thrust::inclusive_scan_by_key(thrust::host, keys, keys + 10, data, data, binary_pred, binary_op); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator inclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op);
+
+
+/*! \p inclusive_scan_by_key computes an inclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'inclusive' means that each result includes 
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate inclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p inclusive_scan_by_key uses the binary predicate 
+ *  \c pred to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1)</tt>
+ *  belong to the same segment if <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to 
+ *  different segments otherwise.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  This version of \p inclusive_scan_by_key uses the associative operator 
+ *  \c binary_op to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param binary_pred  The binary predicate used to determine equality of keys.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p inclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int>     binary_op;
+ *
+ *  thrust::inclusive_scan_by_key(keys, keys + 10, data, data, binary_pred, binary_op); // in-place scan
+ *
+ *  // data is now {1, 2, 3, 1, 2, 1, 1, 2, 3, 4};
+ *  \endcode
+ *
+ *  \see inclusive_scan
+ *  \see exclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+  OutputIterator inclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive segmented prefix 
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c 0 to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ * 
+ *  This version of \p exclusive_scan_by_key assumes \c equal_to as the binary
+ *  predicate used to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1</tt>
+ *  belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to 
+ *  different segments otherwise.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  Refer to the most general form of \p exclusive_scan_by_key for additional details.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals); // in-place scan
+ *
+ *  // vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive segmented prefix 
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c 0 to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key assumes \c plus as the associative
+ *  operator used to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ * 
+ *  This version of \p exclusive_scan_by_key assumes \c equal_to as the binary
+ *  predicate used to compare adjacent keys.  Specifically, consecutive iterators
+ *  <tt>i</tt> and <tt>i+1</tt> in the range <tt>[first1, last1</tt>
+ *  belong to the same segment if <tt>*i == *(i+1)</tt>, and belong to 
+ *  different segments otherwise.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  Refer to the most general form of \p exclusive_scan_by_key for additional details.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key.
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  thrust::exclusive_scan_by_key(key, key + 10, vals, vals); // in-place scan
+ *
+ *  // vals is now {0, 1, 2, 0, 1, 0, 0, 1, 2, 3};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \return The end of the output sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key using the \p
+ *  thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \return The end of the output sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
+ *  to compare adjacent keys.  Specifically, consecutive iterators <tt>i</tt> and
+ *  <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if
+ *  <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \param binary_pred The binary predicate used to determine equality of keys.
+ *  \return The end of the output sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *
+ *  thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
+ *  to compare adjacent keys.  Specifically, consecutive iterators <tt>i</tt> and
+ *  <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if
+ *  <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \param binary_pred The binary predicate used to determine equality of keys.
+ *  \return The end of the output sequence.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *
+ *  thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
+ *  to compare adjacent keys.  Specifically, consecutive iterators <tt>i</tt> and
+ *  <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if 
+ *  <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise.
+ *
+ *  This version of \p exclusive_scan_by_key uses the associative operator 
+ *  \c binary_op to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \param binary_pred The binary predicate used to determine equality of keys.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                         and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int>     binary_op;
+ *
+ *  thrust::exclusive_scan_by_key(thrust::host, key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator exclusive_scan_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op);
+
+
+/*! \p exclusive_scan_by_key computes an exclusive key-value or 'segmented' prefix 
+ *  sum operation. The term 'exclusive' means that each result does not include
+ *  the corresponding input operand in the partial sum. The term 'segmented'
+ *  means that the partial sums are broken into distinct segments.  In other
+ *  words, within each segment a separate exclusive scan operation is computed.
+ *  Refer to the code sample below for example usage.
+ *
+ *  This version of \p exclusive_scan_by_key uses the value \c init to
+ *  initialize the exclusive scan operation.
+ *
+ *  This version of \p exclusive_scan_by_key uses the binary predicate \c binary_pred
+ *  to compare adjacent keys.  Specifically, consecutive iterators <tt>i</tt> and
+ *  <tt>i+1</tt> in the range <tt>[first1, last1)</tt> belong to the same segment if 
+ *  <tt>binary_pred(*i, *(i+1))</tt> is true, and belong to different segments otherwise.
+ *
+ *  This version of \p exclusive_scan_by_key uses the associative operator 
+ *  \c binary_op to perform the prefix sum. When the input and output sequences
+ *  are the same, the scan is performed in-place.
+ *
+ *  Results are not deterministic for pseudo-associative operators (e.g.,
+ *  addition of floating-point types). Results for pseudo-associative
+ *  operators may vary from run to run.
+ *
+ *  \param first1 The beginning of the key sequence.
+ *  \param last1 The end of the key sequence.
+ *  \param first2 The beginning of the input value sequence.
+ *  \param result The beginning of the output value sequence.
+ *  \param init The initial of the exclusive sum value.
+ *  \param binary_pred The binary predicate used to determine equality of keys.
+ *  \param binary_op The associatve operator used to 'sum' values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>,
+ *                         and if \c x and \c y are objects of \c OutputIterator's \c value_type, then 
+ *                         <tt>binary_op(x,y)</tt> is defined.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                         and \c AssociativeOperator's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result but the range <tt>[first1, last1)</tt> and the range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *  \pre \p first2 may equal \p result but the range <tt>[first2, first2 + (last1 - first1)</tt> and range <tt>[result, result + (last1 - first1))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p exclusive_scan_by_key
+ *
+ *  \code
+ *  #include <thrust/scan.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int keys[10] = {0, 0, 0, 1, 1, 2, 3, 3, 3, 3};
+ *  int vals[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+ *
+ *  int init = 5;
+ *
+ *  thrust::equal_to<int> binary_pred;
+ *  thrust::plus<int>     binary_op;
+ *
+ *  thrust::exclusive_scan_by_key(key, key + 10, vals, vals, init, binary_pred, binary_op); // in-place scan
+ *
+ *  // vals is now {5, 6, 7, 5, 6, 5, 5, 6, 7, 8};
+ *  \endcode
+ *
+ *  \see exclusive_scan
+ *  \see inclusive_scan_by_key
+ *
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename T,
+         typename BinaryPredicate,
+         typename AssociativeOperator>
+  OutputIterator exclusive_scan_by_key(InputIterator1 first1,
+                                       InputIterator1 last1,
+                                       InputIterator2 first2,
+                                       OutputIterator result,
+                                       T init,
+                                       BinaryPredicate binary_pred,
+                                       AssociativeOperator binary_op);
+
+
+/*! \} // end segmentedprefixsums
+ */
+
+
+/*! \} // end prefix sums
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/scan.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scatter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8b0bd84f52a511a7b58eedbeaa1d34873ee0893
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/scatter.h
@@ -0,0 +1,419 @@
+/*
+ *  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 scatter.h
+ *  \brief Irregular copying to a destination range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup scattering
+ *  \ingroup copying
+ *  \{
+ */
+
+
+/*! \p scatter copies elements from a source range into an output array
+ *  according to a map. For each iterator \c i in the range [\p first, \p last),
+ *  the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>. The 
+ *  output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>,
+ *  the result is undefined.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map  Beginning of the sequence of output indices.
+ *  \param result Destination of the source elements.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators in the range `[map,map + (last - first))`.
+ *
+ *  The following code snippet demonstrates how to use \p scatter to
+ *  reorder a range using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  // mark even indices with a 1; odd indices with a 0
+ *  int values[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // scatter all even indices into the first half of the
+ *  // range, and odd indices vice versa
+ *  int map[10]   = {0, 5, 1, 6, 2, 7, 3, 8, 4, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10);
+ *  thrust::scatter(thrust::device,
+ *                  d_values.begin(), d_values.end(),
+ *                  d_map.begin(), d_output.begin());
+ *  // d_output is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  \endcode
+ *
+ *  \note \p scatter is the inverse of thrust::gather.
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator>
+__host__ __device__
+  void scatter(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+               InputIterator1 first,
+               InputIterator1 last,
+               InputIterator2 map,
+               RandomAccessIterator result);
+
+
+/*! \p scatter copies elements from a source range into an output array
+ *  according to a map. For each iterator \c i in the range [\p first, \p last),
+ *  the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>. The 
+ *  output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>,
+ *  the result is undefined.
+ *
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map  Beginning of the sequence of output indices.
+ *  \param result Destination of the source elements.
+ *
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators in the range `[map,map + (last - first))`.
+ *
+ *  The following code snippet demonstrates how to use \p scatter to
+ *  reorder a range.
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  // mark even indices with a 1; odd indices with a 0
+ *  int values[10] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+ *  thrust::device_vector<int> d_values(values, values + 10);
+ *
+ *  // scatter all even indices into the first half of the
+ *  // range, and odd indices vice versa
+ *  int map[10]   = {0, 5, 1, 6, 2, 7, 3, 8, 4, 9};
+ *  thrust::device_vector<int> d_map(map, map + 10);
+ *
+ *  thrust::device_vector<int> d_output(10);
+ *  thrust::scatter(d_values.begin(), d_values.end(),
+ *                  d_map.begin(), d_output.begin());
+ *  // d_output is now {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}
+ *  \endcode
+ *
+ *  \note \p scatter is the inverse of thrust::gather.
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator>
+  void scatter(InputIterator1 first,
+               InputIterator1 last,
+               InputIterator2 map,
+               RandomAccessIterator result);
+
+
+/*! \p scatter_if conditionally copies elements from a source range into an 
+ *  output array according to a map. For each iterator \c i in the 
+ *  range <tt>[first, last)</tt> such that <tt>*(stencil + (i - first))</tt> is
+ *  true, the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>.
+ *  The output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>
+ *  the result is undefined.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map Beginning of the sequence of output indices.
+ *  \param stencil Beginning of the sequence of predicate values.
+ *  \param output Beginning of the destination range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator3 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator3's \c value_type must be convertible to \c bool.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[stencil,stencil + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators `i` in the range `[map,map + (last - first))` for which the following condition holds: `*(stencil + i) != false`.
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int V[8] = {10, 20, 30, 40, 50, 60, 70, 80};
+ *  int M[8] = {0, 5, 1, 6, 2, 7, 3, 4};
+ *  int S[8] = {1, 0, 1, 0, 1, 0, 1, 0};
+ *  int D[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ * 
+ *  thrust::scatter_if(thrust::host, V, V + 8, M, S, D);
+ * 
+ *  // D contains [10, 30, 50, 70, 0, 0, 0, 0];
+ *  \endcode
+ *
+ *  \note \p scatter_if is the inverse of thrust::gather_if.
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator>
+__host__ __device__
+  void scatter_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output);
+
+
+/*! \p scatter_if conditionally copies elements from a source range into an 
+ *  output array according to a map. For each iterator \c i in the 
+ *  range <tt>[first, last)</tt> such that <tt>*(stencil + (i - first))</tt> is
+ *  true, the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>.
+ *  The output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>
+ *  the result is undefined.
+ *
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map Beginning of the sequence of output indices.
+ *  \param stencil Beginning of the sequence of predicate values.
+ *  \param output Beginning of the destination range.
+ *
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator3 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator3's \c value_type must be convertible to \c bool.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[stencil,stencil + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators `i` in the range `[map,map + (last - first))` for which the following condition holds: `*(stencil + i) != false`.
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *  ...
+ *  int V[8] = {10, 20, 30, 40, 50, 60, 70, 80};
+ *  int M[8] = {0, 5, 1, 6, 2, 7, 3, 4};
+ *  int S[8] = {1, 0, 1, 0, 1, 0, 1, 0};
+ *  int D[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ * 
+ *  thrust::scatter_if(V, V + 8, M, S, D);
+ * 
+ *  // D contains [10, 30, 50, 70, 0, 0, 0, 0];
+ *  \endcode
+ *
+ *  \note \p scatter_if is the inverse of thrust::gather_if.
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator>
+  void scatter_if(InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output);
+
+
+/*! \p scatter_if conditionally copies elements from a source range into an 
+ *  output array according to a map. For each iterator \c i in the 
+ *  range <tt>[first, last)</tt> such that <tt>pred(*(stencil + (i - first)))</tt> is
+ *  \c true, the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>.
+ *  The output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>
+ *  the result is undefined.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map Beginning of the sequence of output indices.
+ *  \param stencil Beginning of the sequence of predicate values.
+ *  \param output Beginning of the destination range.
+ *  \param pred Predicate to apply to the stencil values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator3 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator3's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[stencil,stencil + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators `i` in the range `[map,map + (last - first))` for which the following condition holds: `pred(*(stencil + i)) != false`.
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *
+ *  int V[8] = {10, 20, 30, 40, 50, 60, 70, 80};
+ *  int M[8] = {0, 5, 1, 6, 2, 7, 3, 4};
+ *  int S[8] = {2, 1, 2, 1, 2, 1, 2, 1};
+ *  int D[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ * 
+ *  is_even pred;
+ *  thrust::scatter_if(thrust::host, V, V + 8, M, S, D, pred);
+ * 
+ *  // D contains [10, 30, 50, 70, 0, 0, 0, 0];
+ *  \endcode
+ *  
+ *  \note \p scatter_if is the inverse of thrust::gather_if.
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator,
+         typename Predicate>
+__host__ __device__
+  void scatter_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output,
+                  Predicate pred);
+                  
+
+/*! \p scatter_if conditionally copies elements from a source range into an 
+ *  output array according to a map. For each iterator \c i in the 
+ *  range <tt>[first, last)</tt> such that <tt>pred(*(stencil + (i - first)))</tt> is
+ *  \c true, the value \c *i is assigned to <tt>output[*(map + (i - first))]</tt>.
+ *  The output iterator must permit random access. If the same index 
+ *  appears more than once in the range <tt>[map, map + (last - first))</tt>
+ *  the result is undefined.
+ *
+ *  \param first Beginning of the sequence of values to scatter.
+ *  \param last End of the sequence of values to scatter.
+ *  \param map Beginning of the sequence of output indices.
+ *  \param stencil Beginning of the sequence of predicate values.
+ *  \param output Beginning of the destination range.
+ *  \param pred Predicate to apply to the stencil values.
+ *
+ *  \tparam InputIterator1 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator1's \c value_type must be convertible to \c RandomAccessIterator's \c value_type.
+ *  \tparam InputIterator2 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator2's \c value_type must be convertible to \c RandomAccessIterator's \c difference_type.
+ *  \tparam InputIterator3 must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator3's \c value_type must be convertible to \c Predicate's \c argument_type.
+ *  \tparam RandomAccessIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access iterator</a>.
+ *  \tparam Predicate must be a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[first,last)` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[map,map + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The iterator `result + i` shall not refer to any element referenced by any iterator `j` in the range `[stencil,stencil + (last - first))` for all iterators `i` in the range `[map,map + (last - first))`.
+ *
+ *  \pre The expression `result[*i]` shall be valid for all iterators `i` in the range `[map,map + (last - first))` for which the following condition holds: `pred(*(stencil + i)) != false`.
+ *
+ *  \code
+ *  #include <thrust/scatter.h>
+ *
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *
+ *  ...
+ *
+ *  int V[8] = {10, 20, 30, 40, 50, 60, 70, 80};
+ *  int M[8] = {0, 5, 1, 6, 2, 7, 3, 4};
+ *  int S[8] = {2, 1, 2, 1, 2, 1, 2, 1};
+ *  int D[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ * 
+ *  is_even pred;
+ *  thrust::scatter_if(V, V + 8, M, S, D, pred);
+ * 
+ *  // D contains [10, 30, 50, 70, 0, 0, 0, 0];
+ *  \endcode
+ *  
+ *  \note \p scatter_if is the inverse of thrust::gather_if.
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename RandomAccessIterator,
+         typename Predicate>
+  void scatter_if(InputIterator1 first,
+                  InputIterator1 last,
+                  InputIterator2 map,
+                  InputIterator3 stencil,
+                  RandomAccessIterator output,
+                  Predicate pred);
+
+
+/*! \} // end scattering
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/scatter.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sequence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb3959e3cabea72e17d9641744a02cadc1d0d07d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sequence.h
@@ -0,0 +1,293 @@
+/*
+ *  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 sequence.h
+ *  \brief Fills a range with a sequence of numbers
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \{
+ */
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  (i - first)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(thrust::host, A, A + 10);
+ *  // A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last);
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  (i - first)</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers.
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(A, A + 10);
+ *  // A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename ForwardIterator>
+  void sequence(ForwardIterator first,
+                ForwardIterator last);
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  init + (i - first)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param init The first value of the sequence of numbers.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers starting from the value 1 using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(thrust::host, A, A + 10, 1);
+ *  // A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                T init);
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  init + (i - first)</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param init The first value of the sequence of numbers.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers starting from the value 1.
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(A, A + 10, 1);
+ *  // A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename ForwardIterator, typename T>
+  void sequence(ForwardIterator first,
+                ForwardIterator last,
+                T init);
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  init + step * (i - first)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param init The first value of the sequence of numbers
+ *  \param step The difference between consecutive elements.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers starting from the value 1 with a step size of 3 using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(thrust::host, A, A + 10, 1, 3);
+ *  // A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                T init,
+                T step);
+
+
+/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
+ *  \p sequence performs the assignment <tt>*i =  init + step * (i - first)</tt>.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param init The first value of the sequence of numbers
+ *  \param step The difference between consecutive elements.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam T is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and \p T is convertible to \p ForwardIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p sequence to fill a range
+ *  with a sequence of numbers starting from the value 1 with a step size of 3.
+ *
+ *  \code
+ *  #include <thrust/sequence.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::sequence(A, A + 10, 1, 3);
+ *  // A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}
+ *  \endcode
+ *
+ *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
+ *        guarantee on order of execution.
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/iota
+ */
+template<typename ForwardIterator, typename T>
+  void sequence(ForwardIterator first,
+                ForwardIterator last,
+                T init,
+                T step);
+
+
+/*! \} // end transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/sequence.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/set_operations.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/set_operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..65a48d1b66129d7f0c2884b399e82d196786962f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/set_operations.h
@@ -0,0 +1,2959 @@
+/*
+ *  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 set_operations.h
+ *  \brief Set theoretic operations for sorted ranges
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup set_operations Set Operations
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p set_difference constructs a sorted range that is the set difference of the sorted
+ *  ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_difference performs the "difference" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt> and not contained in <tt>[first2, last1)</tt>. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[first1, last1)</tt> range shall be copied to the output range.
+ *
+ *  This version of \p set_difference compares elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference to compute the
+ *  set difference of two sets of integers sorted in ascending order using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {0, 1, 3, 4, 5, 6, 9};
+ *  int A2[5] = {1, 3, 5, 7, 9};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
+ *  // result is now {0, 4, 6}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_difference
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator set_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator1                                              first1,
+                                InputIterator1                                              last1,
+                                InputIterator2                                              first2,
+                                InputIterator2                                              last2,
+                                OutputIterator                                              result);
+
+
+/*! \p set_difference constructs a sorted range that is the set difference of the sorted
+ *  ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_difference performs the "difference" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt> and not contained in <tt>[first2, last1)</tt>. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[first1, last1)</tt> range shall be copied to the output range.
+ *
+ *  This version of \p set_difference compares elements using \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference to compute the
+ *  set difference of two sets of integers sorted in ascending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[7] = {0, 1, 3, 4, 5, 6, 9};
+ *  int A2[5] = {1, 3, 5, 7, 9};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_difference(A1, A1 + 7, A2, A2 + 5, result);
+ *  // result is now {0, 4, 6}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_difference
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_difference(InputIterator1 first1,
+                                InputIterator1 last1,
+                                InputIterator2 first2,
+                                InputIterator2 last2,
+                                OutputIterator result);
+
+
+/*! \p set_difference constructs a sorted range that is the set difference of the sorted
+ *  ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_difference performs the "difference" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt> and not contained in <tt>[first2, last1)</tt>. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[first1, last1)</tt> range shall be copied to the output range.
+ *
+ *  This version of \p set_difference compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference to compute the
+ *  set difference of two sets of integers sorted in descending order using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {9, 6, 5, 4, 3, 1, 0};
+ *  int A2[5] = {9, 7, 5, 3, 1};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
+ *  // result is now {6, 4, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_difference
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator set_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                InputIterator1                                              first1,
+                                InputIterator1                                              last1,
+                                InputIterator2                                              first2,
+                                InputIterator2                                              last2,
+                                OutputIterator                                              result,
+                                StrictWeakCompare                                           comp);
+
+
+/*! \p set_difference constructs a sorted range that is the set difference of the sorted
+ *  ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_difference performs the "difference" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt> and not contained in <tt>[first2, last1)</tt>. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[first1, last1)</tt> range shall be copied to the output range.
+ *
+ *  This version of \p set_difference compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference to compute the
+ *  set difference of two sets of integers sorted in descending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A1[7] = {9, 6, 5, 4, 3, 1, 0};
+ *  int A2[5] = {9, 7, 5, 3, 1};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_difference(A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
+ *  // result is now {6, 4, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_difference
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+  OutputIterator set_difference(InputIterator1 first1,
+                                InputIterator1 last1,
+                                InputIterator2 first2,
+                                InputIterator2 last2,
+                                OutputIterator result,
+                                StrictWeakCompare comp);
+
+
+/*! \p set_intersection constructs a sorted range that is the
+ *  intersection of sorted ranges <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt>. The return value is the end of the
+ *  output range.
+ *
+ *  In the simplest case, \p set_intersection performs the
+ *  "intersection" operation from set theory: the output range
+ *  contains a copy of every element that is contained in both
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The
+ *  general case is more complicated, because the input ranges may
+ *  contain duplicate elements. The generalization is that if a value
+ *  appears \c m times in <tt>[first1, last1)</tt> and \c n times in
+ *  <tt>[first2, last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the output range.
+ *  \p set_intersection is stable, meaning that both elements are
+ *  copied from the first range rather than the second, and that the
+ *  relative order of elements in the output range is the same as in
+ *  the first input range.
+ *
+ *  This version of \p set_intersection compares objects using
+ *  \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection to compute the
+ *  set intersection of two sets of integers sorted in ascending order using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[7];
+ *
+ *  int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result);
+ *  // result is now {1, 3, 5}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_intersection
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator set_intersection(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  InputIterator1                                              first1,
+                                  InputIterator1                                              last1,
+                                  InputIterator2                                              first2,
+                                  InputIterator2                                              last2,
+                                  OutputIterator                                              result);
+
+
+/*! \p set_intersection constructs a sorted range that is the
+ *  intersection of sorted ranges <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt>. The return value is the end of the
+ *  output range.
+ *
+ *  In the simplest case, \p set_intersection performs the
+ *  "intersection" operation from set theory: the output range
+ *  contains a copy of every element that is contained in both
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The
+ *  general case is more complicated, because the input ranges may
+ *  contain duplicate elements. The generalization is that if a value
+ *  appears \c m times in <tt>[first1, last1)</tt> and \c n times in
+ *  <tt>[first2, last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the output range.
+ *  \p set_intersection is stable, meaning that both elements are
+ *  copied from the first range rather than the second, and that the
+ *  relative order of elements in the output range is the same as in
+ *  the first input range.
+ *
+ *  This version of \p set_intersection compares objects using
+ *  \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection to compute the
+ *  set intersection of two sets of integers sorted in ascending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[6] = {1, 3, 5, 7, 9, 11};
+ *  int A2[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int result[7];
+ *
+ *  int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result);
+ *  // result is now {1, 3, 5}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_intersection
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_intersection(InputIterator1 first1,
+                                  InputIterator1 last1,
+                                  InputIterator2 first2,
+                                  InputIterator2 last2,
+                                  OutputIterator result);
+
+
+/*! \p set_intersection constructs a sorted range that is the
+ *  intersection of sorted ranges <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt>. The return value is the end of the
+ *  output range.
+ *
+ *  In the simplest case, \p set_intersection performs the
+ *  "intersection" operation from set theory: the output range
+ *  contains a copy of every element that is contained in both
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The
+ *  general case is more complicated, because the input ranges may
+ *  contain duplicate elements. The generalization is that if a value
+ *  appears \c m times in <tt>[first1, last1)</tt> and \c n times in
+ *  <tt>[first2, last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the output range.
+ *  \p set_intersection is stable, meaning that both elements are
+ *  copied from the first range rather than the second, and that the
+ *  relative order of elements in the output range is the same as in
+ *  the first input range.
+ *
+ *  This version of \p set_intersection compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection to compute
+ *  the set intersection of sets of integers sorted in descending order using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2,  1, 1};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_intersection(thrust::host, A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
+ *  // result is now {5, 3, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_intersection
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator set_intersection(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  InputIterator1                                              first1,
+                                  InputIterator1                                              last1,
+                                  InputIterator2                                              first2,
+                                  InputIterator2                                              last2,
+                                  OutputIterator                                              result,
+                                  StrictWeakCompare                                           comp);
+
+
+/*! \p set_intersection constructs a sorted range that is the
+ *  intersection of sorted ranges <tt>[first1, last1)</tt> and
+ *  <tt>[first2, last2)</tt>. The return value is the end of the
+ *  output range.
+ *
+ *  In the simplest case, \p set_intersection performs the
+ *  "intersection" operation from set theory: the output range
+ *  contains a copy of every element that is contained in both
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The
+ *  general case is more complicated, because the input ranges may
+ *  contain duplicate elements. The generalization is that if a value
+ *  appears \c m times in <tt>[first1, last1)</tt> and \c n times in
+ *  <tt>[first2, last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the output range.
+ *  \p set_intersection is stable, meaning that both elements are
+ *  copied from the first range rather than the second, and that the
+ *  relative order of elements in the output range is the same as in
+ *  the first input range.
+ *
+ *  This version of \p set_intersection compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection to compute
+ *  the set intersection of sets of integers sorted in descending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[6] = {11, 9, 7, 5, 3, 1};
+ *  int A2[7] = {13, 8, 5, 3, 2,  1, 1};
+ *
+ *  int result[3];
+ *
+ *  int *result_end = thrust::set_intersection(A1, A1 + 6, A2, A2 + 7, result, thrust::greater<int>());
+ *  // result is now {5, 3, 1}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_intersection
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+  OutputIterator set_intersection(InputIterator1 first1,
+                                  InputIterator1 last1,
+                                  InputIterator2 first2,
+                                  InputIterator2 last2,
+                                  OutputIterator result,
+                                  StrictWeakCompare comp);
+
+
+/*! \p set_symmetric_difference constructs a sorted range that is the set symmetric
+ *  difference of the sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *  The return value is the end of the output range.
+ *
+ *  In the simplest case, \p set_symmetric_difference performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[first1, last1)</tt> but not <tt>[first2, last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[first2, last2)</tt> but not <tt>[first1, last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[first2, last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[first1, last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[first2, last2)</tt> if <tt>m < n</tt>.
+ *
+ *  This version of \p set_union compares elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference to compute
+ *  the symmetric difference of two sets of integers sorted in ascending order using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {0, 1, 2, 2, 4, 6, 7};
+ *  int A2[5] = {1, 1, 2, 5, 8};
+ *
+ *  int result[6];
+ *
+ *  int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {0, 4, 5, 6, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_difference
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator1                                              first1,
+                                          InputIterator1                                              last1,
+                                          InputIterator2                                              first2,
+                                          InputIterator2                                              last2,
+                                          OutputIterator                                              result);
+
+
+/*! \p set_symmetric_difference constructs a sorted range that is the set symmetric
+ *  difference of the sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *  The return value is the end of the output range.
+ *
+ *  In the simplest case, \p set_symmetric_difference performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[first1, last1)</tt> but not <tt>[first2, last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[first2, last2)</tt> but not <tt>[first1, last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[first2, last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[first1, last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[first2, last2)</tt> if <tt>m < n</tt>.
+ *
+ *  This version of \p set_union compares elements using \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference to compute
+ *  the symmetric difference of two sets of integers sorted in ascending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[7] = {0, 1, 2, 2, 4, 6, 7};
+ *  int A2[5] = {1, 1, 2, 5, 8};
+ *
+ *  int result[6];
+ *
+ *  int *result_end = thrust::set_symmetric_difference(A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {0, 4, 5, 6, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_difference
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_symmetric_difference(InputIterator1 first1,
+                                          InputIterator1 last1,
+                                          InputIterator2 first2,
+                                          InputIterator2 last2,
+                                          OutputIterator result);
+
+
+/*! \p set_symmetric_difference constructs a sorted range that is the set symmetric
+ *  difference of the sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *  The return value is the end of the output range.
+ *
+ *  In the simplest case, \p set_symmetric_difference performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[first1, last1)</tt> but not <tt>[first2, last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[first2, last2)</tt> but not <tt>[first1, last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[first2, last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[first1, last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[first2, last2)</tt> if <tt>m < n</tt>.
+ *
+ *  This version of \p set_union compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference to compute
+ *  the symmetric difference of two sets of integers sorted in descending order using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {7, 6, 4, 2, 2, 1, 0};
+ *  int A2[5] = {8, 5, 2, 1, 1};
+ *
+ *  int result[6];
+ *
+ *  int *result_end = thrust::set_symmetric_difference(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {8, 7, 6, 5, 4, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_difference
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator set_symmetric_difference(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator1                                              first1,
+                                          InputIterator1                                              last1,
+                                          InputIterator2                                              first2,
+                                          InputIterator2                                              last2,
+                                          OutputIterator                                              result,
+                                          StrictWeakCompare                                           comp);
+
+
+/*! \p set_symmetric_difference constructs a sorted range that is the set symmetric
+ *  difference of the sorted ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>.
+ *  The return value is the end of the output range.
+ *
+ *  In the simplest case, \p set_symmetric_difference performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[first1, last1)</tt> but not <tt>[first2, last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[first2, last2)</tt> but not <tt>[first1, last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[first2, last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[first1, last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[first2, last2)</tt> if <tt>m < n</tt>.
+ *
+ *  This version of \p set_union compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference to compute
+ *  the symmetric difference of two sets of integers sorted in descending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[7] = {7, 6, 4, 2, 2, 1, 0};
+ *  int A2[5] = {8, 5, 2, 1, 1};
+ *
+ *  int result[6];
+ *
+ *  int *result_end = thrust::set_symmetric_difference(A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {8, 7, 6, 5, 4, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_symmetric_difference
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_difference
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+  OutputIterator set_symmetric_difference(InputIterator1 first1,
+                                          InputIterator1 last1,
+                                          InputIterator2 first2,
+                                          InputIterator2 last2,
+                                          OutputIterator result,
+                                          StrictWeakCompare comp);
+
+
+/*! \p set_union constructs a sorted range that is the union of the sorted ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_union performs the "union" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt>, <tt>[first2, last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  This version of \p set_union compares elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_union to compute the union of
+ *  two sets of integers sorted in ascending order using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {0, 2, 4, 6, 8, 10, 12};
+ *  int A2[5] = {1, 3, 5, 7, 9};
+ *
+ *  int result[11];
+ *
+ *  int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_union
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator set_union(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              first1,
+                           InputIterator1                                              last1,
+                           InputIterator2                                              first2,
+                           InputIterator2                                              last2,
+                           OutputIterator                                              result);
+
+
+/*! \p set_union constructs a sorted range that is the union of the sorted ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_union performs the "union" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt>, <tt>[first2, last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  This version of \p set_union compares elements using \c operator<.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_union to compute the union of
+ *  two sets of integers sorted in ascending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A1[7] = {0, 2, 4, 6, 8, 10, 12};
+ *  int A2[5] = {1, 3, 5, 7, 9};
+ *
+ *  int result[11];
+ *
+ *  int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result);
+ *  // result = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_union
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator set_union(InputIterator1 first1,
+                           InputIterator1 last1,
+                           InputIterator2 first2,
+                           InputIterator2 last2,
+                           OutputIterator result);
+
+
+/*! \p set_union constructs a sorted range that is the union of the sorted ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_union performs the "union" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt>, <tt>[first2, last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  This version of \p set_union compares elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_union to compute the union of
+ *  two sets of integers sorted in ascending order using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A1[7] = {12, 10, 8, 6, 4, 2, 0};
+ *  int A2[5] = {9, 7, 5, 3, 1};
+ *
+ *  int result[11];
+ *
+ *  int *result_end = thrust::set_union(thrust::host, A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
+ *  // result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_union
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator set_union(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              first1,
+                           InputIterator1                                              last1,
+                           InputIterator2                                              first2,
+                           InputIterator2                                              last2,
+                           OutputIterator                                              result,
+                           StrictWeakCompare                                           comp);
+
+
+/*! \p set_union constructs a sorted range that is the union of the sorted ranges
+ *  <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt>. The return value is the
+ *  end of the output range.
+ *
+ *  In the simplest case, \p set_union performs the "union" operation from set
+ *  theory: the output range contains a copy of every element that is contained in
+ *  <tt>[first1, last1)</tt>, <tt>[first2, last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[first1, last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[first2, last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  This version of \p set_union compares elements using a function object \p comp.
+ *
+ *  \param first1 The beginning of the first input range.
+ *  \param last1 The end of the first input range.
+ *  \param first2 The beginning of the second input range.
+ *  \param last2 The end of the second input range.
+ *  \param result The beginning of the output range.
+ *  \param comp Comparison operator.
+ *  \return The end of the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1's \c value_type is convertable to \p StrictWeakCompare's \c first_argument_type.
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2's \c value_type is convertable to \p StrictWeakCompare's \c second_argument_type.
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[first1, last1)</tt> and <tt>[first2, last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting range shall not overlap with either input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_union to compute the union of
+ *  two sets of integers sorted in ascending order.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A1[7] = {12, 10, 8, 6, 4, 2, 0};
+ *  int A2[5] = {9, 7, 5, 3, 1};
+ *
+ *  int result[11];
+ *
+ *  int *result_end = thrust::set_union(A1, A1 + 7, A2, A2 + 5, result, thrust::greater<int>());
+ *  // result = {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/set_union
+ *  \see \p merge
+ *  \see \p includes
+ *  \see \p set_union
+ *  \see \p set_intersection
+ *  \see \p set_symmetric_difference
+ *  \see \p sort
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+  OutputIterator set_union(InputIterator1 first1,
+                           InputIterator1 last1,
+                           InputIterator2 first2,
+                           InputIterator2 last2,
+                           OutputIterator result,
+                           StrictWeakCompare comp);
+
+
+/*! \p set_difference_by_key performs a key-value difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_difference_by_key performs the "difference" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt> and not contained in <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[keys_first1, keys_last1)</tt> range shall be copied to the output range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_difference_by_key compares key elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference_by_key to compute the
+ *  set difference of two sets of integers sorted in ascending order with their values using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {1, 3, 5, 7, 9};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[3];
+ *  int vals_result[3];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 4, 6}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1                                              keys_first1,
+                          InputIterator1                                              keys_last1,
+                          InputIterator2                                              keys_first2,
+                          InputIterator2                                              keys_last2,
+                          InputIterator3                                              values_first1,
+                          InputIterator4                                              values_first2,
+                          OutputIterator1                                             keys_result,
+                          OutputIterator2                                             values_result);
+
+
+/*! \p set_difference_by_key performs a key-value difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_difference_by_key performs the "difference" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt> and not contained in <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[keys_first1, keys_last1)</tt> range shall be copied to the output range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_difference_by_key compares key elements using \c operator<.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference_by_key to compute the
+ *  set difference of two sets of integers sorted in ascending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A_keys[6] = {0, 1, 3, 4, 5, 6, 9};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {1, 3, 5, 7, 9};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[3];
+ *  int vals_result[3];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 4, 6}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(InputIterator1                             keys_first1,
+                          InputIterator1                             keys_last1,
+                          InputIterator2                             keys_first2,
+                          InputIterator2                             keys_last2,
+                          InputIterator3                             values_first1,
+                          InputIterator4                             values_first2,
+                          OutputIterator1                            keys_result,
+                          OutputIterator2                            values_result);
+
+
+/*! \p set_difference_by_key performs a key-value difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_difference_by_key performs the "difference" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt> and not contained in <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[keys_first1, keys_last1)</tt> range shall be copied to the output range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_difference_by_key compares key elements using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference_by_key to compute the
+ *  set difference of two sets of integers sorted in descending order with their values using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {9, 7, 5, 3, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[3];
+ *  int vals_result[3];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
+ *  // keys_result is now {0, 4, 6}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          InputIterator1                                              keys_first1,
+                          InputIterator1                                              keys_last1,
+                          InputIterator2                                              keys_first2,
+                          InputIterator2                                              keys_last2,
+                          InputIterator3                                              values_first1,
+                          InputIterator4                                              values_first2,
+                          OutputIterator1                                             keys_result,
+                          OutputIterator2                                             values_result,
+                          StrictWeakCompare                                           comp);
+
+
+/*! \p set_difference_by_key performs a key-value difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_difference_by_key performs the "difference" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt> and not contained in <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, the last <tt>max(m-n,0)</tt> elements from
+ *  <tt>[keys_first1, keys_last1)</tt> range shall be copied to the output range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_difference_by_key compares key elements using a function object \p comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_difference_by_key to compute the
+ *  set difference of two sets of integers sorted in descending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {9, 6, 5, 4, 3, 1, 0};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {9, 7, 5, 3, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[3];
+ *  int vals_result[3];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
+ *  // keys_result is now {0, 4, 6}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_difference_by_key(InputIterator1                             keys_first1,
+                          InputIterator1                             keys_last1,
+                          InputIterator2                             keys_first2,
+                          InputIterator2                             keys_last2,
+                          InputIterator3                             values_first1,
+                          InputIterator4                             values_first2,
+                          OutputIterator1                            keys_result,
+                          OutputIterator2                            values_result,
+                          StrictWeakCompare                          comp);
+
+
+/*! \p set_intersection_by_key performs a key-value intersection operation from set theory.
+ *  \p set_intersection_by_key constructs a sorted range that is the intersection of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_intersection_by_key performs the "intersection" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in both
+ *  <tt>[keys_first1, keys_last1)</tt> <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if an element appears \c m times in <tt>[keys_first1, keys_last1)</tt>
+ *  and \c n times in <tt>[keys_first2, keys_last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the keys output range.
+ *  \p set_intersection_by_key is stable, meaning both that elements are copied from the first
+ *  input range rather than the second, and that the relative order of elements in the output range
+ *  is the same as the first input range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> to the keys output range,
+ *  the corresponding value element is copied from <tt>[values_first1, values_last1)</tt> to the values
+ *  output range.
+ *
+ *  This version of \p set_intersection_by_key compares objects using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \note Unlike the other key-value set operations, \p set_intersection_by_key is unique in that it has no
+ *        \c values_first2 parameter because elements from the second input range are never copied to the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection_by_key to compute the
+ *  set intersection of two sets of integers sorted in ascending order with their values using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0,  0};
+ *  
+ *  int B_keys[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int keys_result[7];
+ *  int vals_result[7];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_intersection_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result);
+ *
+ *  // keys_result is now {1, 3, 5}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            InputIterator1                                              keys_first1,
+                            InputIterator1                                              keys_last1,
+                            InputIterator2                                              keys_first2,
+                            InputIterator2                                              keys_last2,
+                            InputIterator3                                              values_first1,
+                            OutputIterator1                                             keys_result,
+                            OutputIterator2                                             values_result);
+
+
+/*! \p set_intersection_by_key performs a key-value intersection operation from set theory.
+ *  \p set_intersection_by_key constructs a sorted range that is the intersection of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_intersection_by_key performs the "intersection" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in both
+ *  <tt>[keys_first1, keys_last1)</tt> <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if an element appears \c m times in <tt>[keys_first1, keys_last1)</tt>
+ *  and \c n times in <tt>[keys_first2, keys_last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the keys output range.
+ *  \p set_intersection_by_key is stable, meaning both that elements are copied from the first
+ *  input range rather than the second, and that the relative order of elements in the output range
+ *  is the same as the first input range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> to the keys output range,
+ *  the corresponding value element is copied from <tt>[values_first1, values_last1)</tt> to the values
+ *  output range.
+ *
+ *  This version of \p set_intersection_by_key compares objects using \c operator<.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \note Unlike the other key-value set operations, \p set_intersection_by_key is unique in that it has no
+ *        \c values_first2 parameter because elements from the second input range are never copied to the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection_by_key to compute the
+ *  set intersection of two sets of integers sorted in ascending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A_keys[6] = {1, 3, 5, 7, 9, 11};
+ *  int A_vals[6] = {0, 0, 0, 0, 0,  0};
+ *  
+ *  int B_keys[7] = {1, 1, 2, 3, 5,  8, 13};
+ *
+ *  int keys_result[7];
+ *  int vals_result[7];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_intersection_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result);
+ *
+ *  // keys_result is now {1, 3, 5}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(InputIterator1                             keys_first1,
+                            InputIterator1                             keys_last1,
+                            InputIterator2                             keys_first2,
+                            InputIterator2                             keys_last2,
+                            InputIterator3                             values_first1,
+                            OutputIterator1                            keys_result,
+                            OutputIterator2                            values_result);
+
+
+/*! \p set_intersection_by_key performs a key-value intersection operation from set theory.
+ *  \p set_intersection_by_key constructs a sorted range that is the intersection of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_intersection_by_key performs the "intersection" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in both
+ *  <tt>[keys_first1, keys_last1)</tt> <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if an element appears \c m times in <tt>[keys_first1, keys_last1)</tt>
+ *  and \c n times in <tt>[keys_first2, keys_last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the keys output range.
+ *  \p set_intersection_by_key is stable, meaning both that elements are copied from the first
+ *  input range rather than the second, and that the relative order of elements in the output range
+ *  is the same as the first input range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> to the keys output range,
+ *  the corresponding value element is copied from <tt>[values_first1, values_last1)</tt> to the values
+ *  output range.
+ *
+ *  This version of \p set_intersection_by_key compares objects using a function object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \note Unlike the other key-value set operations, \p set_intersection_by_key is unique in that it has no
+ *        \c values_first2 parameter because elements from the second input range are never copied to the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection_by_key to compute the
+ *  set intersection of two sets of integers sorted in descending order with their values using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *  
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int keys_result[7];
+ *  int vals_result[7];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_intersection_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result, thrust::greater<int>());
+ *
+ *  // keys_result is now {5, 3, 1}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            InputIterator1                                              keys_first1,
+                            InputIterator1                                              keys_last1,
+                            InputIterator2                                              keys_first2,
+                            InputIterator2                                              keys_last2,
+                            InputIterator3                                              values_first1,
+                            OutputIterator1                                             keys_result,
+                            OutputIterator2                                             values_result,
+                            StrictWeakCompare                                           comp);
+
+
+/*! \p set_intersection_by_key performs a key-value intersection operation from set theory.
+ *  \p set_intersection_by_key constructs a sorted range that is the intersection of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_intersection_by_key performs the "intersection" operation from set
+ *  theory: the keys output range contains a copy of every element that is contained in both
+ *  <tt>[keys_first1, keys_last1)</tt> <tt>[keys_first2, keys_last2)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if an element appears \c m times in <tt>[keys_first1, keys_last1)</tt>
+ *  and \c n times in <tt>[keys_first2, keys_last2)</tt> (where \c m may be zero), then it
+ *  appears <tt>min(m,n)</tt> times in the keys output range.
+ *  \p set_intersection_by_key is stable, meaning both that elements are copied from the first
+ *  input range rather than the second, and that the relative order of elements in the output range
+ *  is the same as the first input range.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> to the keys output range,
+ *  the corresponding value element is copied from <tt>[values_first1, values_last1)</tt> to the values
+ *  output range.
+ *
+ *  This version of \p set_intersection_by_key compares objects using a function object \p comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \note Unlike the other key-value set operations, \p set_intersection_by_key is unique in that it has no
+ *        \c values_first2 parameter because elements from the second input range are never copied to the output range.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_intersection_by_key to compute the
+ *  set intersection of two sets of integers sorted in descending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {11, 9, 7, 5, 3, 1};
+ *  int A_vals[6] = { 0, 0, 0, 0, 0, 0};
+ *  
+ *  int B_keys[7] = {13, 8, 5, 3, 2, 1, 1};
+ *
+ *  int keys_result[7];
+ *  int vals_result[7];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_intersection_by_key(A_keys, A_keys + 6, B_keys, B_keys + 7, A_vals, keys_result, vals_result, thrust::greater<int>());
+ *
+ *  // keys_result is now {5, 3, 1}
+ *  // vals_result is now {0, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_intersection_by_key(InputIterator1                             keys_first1,
+                            InputIterator1                             keys_last1,
+                            InputIterator2                             keys_first2,
+                            InputIterator2                             keys_last2,
+                            InputIterator3                             values_first1,
+                            OutputIterator1                            keys_result,
+                            OutputIterator2                            values_result,
+                            StrictWeakCompare                          comp);
+
+
+/*! \p set_symmetric_difference_by_key performs a key-value symmetric difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the symmetric difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_symmetric_difference_by_key performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[keys_first1, keys_last1)</tt> but not <tt>[keys_first2, keys_last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[keys_first2, keys_last2)</tt> but not <tt>[keys_first1, keys_last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[keys_first2, keys_last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[keys_first1, keys_last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[keys_first2, keys_last2)</tt> if <tt>m < n</tt>.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_symmetric_difference_by_key compares key elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in ascending order with their values using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {1, 1, 2, 5, 8};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[6];
+ *  int vals_result[6];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 4, 5, 6, 7, 8}
+ *  // vals_result is now {0, 0, 1, 0, 0, 1}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                    InputIterator1                                              keys_first1,
+                                    InputIterator1                                              keys_last1,
+                                    InputIterator2                                              keys_first2,
+                                    InputIterator2                                              keys_last2,
+                                    InputIterator3                                              values_first1,
+                                    InputIterator4                                              values_first2,
+                                    OutputIterator1                                             keys_result,
+                                    OutputIterator2                                             values_result);
+
+
+/*! \p set_symmetric_difference_by_key performs a key-value symmetric difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the symmetric difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_symmetric_difference_by_key performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[keys_first1, keys_last1)</tt> but not <tt>[keys_first2, keys_last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[keys_first2, keys_last2)</tt> but not <tt>[keys_first1, keys_last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[keys_first2, keys_last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[keys_first1, keys_last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[keys_first2, keys_last2)</tt> if <tt>m < n</tt>.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_symmetric_difference_by_key compares key elements using \c operator<.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in ascending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A_keys[6] = {0, 1, 2, 2, 4, 6, 7};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {1, 1, 2, 5, 8};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[6];
+ *  int vals_result[6];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 4, 5, 6, 7, 8}
+ *  // vals_result is now {0, 0, 1, 0, 0, 1}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(InputIterator1                             keys_first1,
+                                    InputIterator1                             keys_last1,
+                                    InputIterator2                             keys_first2,
+                                    InputIterator2                             keys_last2,
+                                    InputIterator3                             values_first1,
+                                    InputIterator4                             values_first2,
+                                    OutputIterator1                            keys_result,
+                                    OutputIterator2                            values_result);
+
+
+/*! \p set_symmetric_difference_by_key performs a key-value symmetric difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the symmetric difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_symmetric_difference_by_key performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[keys_first1, keys_last1)</tt> but not <tt>[keys_first2, keys_last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[keys_first2, keys_last2)</tt> but not <tt>[keys_first1, keys_last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[keys_first2, keys_last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[keys_first1, keys_last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[keys_first2, keys_last2)</tt> if <tt>m < n</tt>.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_symmetric_difference_by_key compares key elements using a function object \c comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in descending order with their values using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {8, 5, 2, 1, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[6];
+ *  int vals_result[6];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {8, 7, 6, 5, 4, 0}
+ *  // vals_result is now {1, 0, 0, 1, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                    InputIterator1                                              keys_first1,
+                                    InputIterator1                                              keys_last1,
+                                    InputIterator2                                              keys_first2,
+                                    InputIterator2                                              keys_last2,
+                                    InputIterator3                                              values_first1,
+                                    InputIterator4                                              values_first2,
+                                    OutputIterator1                                             keys_result,
+                                    OutputIterator2                                             values_result,
+                                    StrictWeakCompare                                           comp);
+
+
+/*! \p set_symmetric_difference_by_key performs a key-value symmetric difference operation from set theory.
+ *  \p set_difference_by_key constructs a sorted range that is the symmetric difference of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_symmetric_difference_by_key performs a set theoretic calculation:
+ *  it constructs the union of the two sets A - B and B - A, where A and B are the two
+ *  input ranges. That is, the output range contains a copy of every element that is
+ *  contained in <tt>[keys_first1, keys_last1)</tt> but not <tt>[keys_first2, keys_last1)</tt>, and a copy of
+ *  every element that is contained in <tt>[keys_first2, keys_last2)</tt> but not <tt>[keys_first1, keys_last1)</tt>.
+ *  The general case is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements that are
+ *  equivalent to each other and <tt>[keys_first2, keys_last1)</tt> contains \c n elements that are
+ *  equivalent to them, then <tt>|m - n|</tt> of those elements shall be copied to the output
+ *  range: the last <tt>m - n</tt> elements from <tt>[keys_first1, keys_last1)</tt> if <tt>m > n</tt>, and
+ *  the last <tt>n - m</tt> of these elements from <tt>[keys_first2, keys_last2)</tt> if <tt>m < n</tt>.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_symmetric_difference_by_key compares key elements using a function object \c comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in descending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {7, 6, 4, 2, 2, 1, 0};
+ *  int A_vals[6] = {0, 0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {8, 5, 2, 1, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[6];
+ *  int vals_result[6];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {8, 7, 6, 5, 4, 0}
+ *  // vals_result is now {1, 0, 0, 1, 0, 0}
+ *  \endcode
+ *
+ *  \see \p set_union_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_symmetric_difference_by_key(InputIterator1                             keys_first1,
+                                    InputIterator1                             keys_last1,
+                                    InputIterator2                             keys_first2,
+                                    InputIterator2                             keys_last2,
+                                    InputIterator3                             values_first1,
+                                    InputIterator4                             values_first2,
+                                    OutputIterator1                            keys_result,
+                                    OutputIterator2                            values_result,
+                                    StrictWeakCompare                          comp);
+
+
+/*! \p set_union_by_key performs a key-value union operation from set theory.
+ *  \p set_union_by_key constructs a sorted range that is the union of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_union_by_key performs the "union" operation from set theory:
+ *  the output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt>, <tt>[keys_first2, keys_last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_union_by_key compares key elements using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in ascending order with their values using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
+ *  int A_vals[6] = {0, 0, 0, 0, 0,  0,  0};
+ *
+ *  int B_keys[5] = {1, 3, 5, 7, 9};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[11];
+ *  int vals_result[11];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
+ *  // vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  0,  0}
+ *  \endcode
+ *
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1                                              keys_first1,
+                     InputIterator1                                              keys_last1,
+                     InputIterator2                                              keys_first2,
+                     InputIterator2                                              keys_last2,
+                     InputIterator3                                              values_first1,
+                     InputIterator4                                              values_first2,
+                     OutputIterator1                                             keys_result,
+                     OutputIterator2                                             values_result);
+
+
+/*! \p set_union_by_key performs a key-value union operation from set theory.
+ *  \p set_union_by_key constructs a sorted range that is the union of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_union_by_key performs the "union" operation from set theory:
+ *  the output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt>, <tt>[keys_first2, keys_last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_union_by_key compares key elements using \c operator<.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to <tt>operator<</tt>.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in ascending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  ...
+ *  int A_keys[6] = {0, 2, 4, 6, 8, 10, 12};
+ *  int A_vals[6] = {0, 0, 0, 0, 0,  0,  0};
+ *
+ *  int B_keys[5] = {1, 3, 5, 7, 9};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[11];
+ *  int vals_result[11];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result);
+ *  // keys_result is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12}
+ *  // vals_result is now {0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  0,  0}
+ *  \endcode
+ *
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(InputIterator1                             keys_first1,
+                     InputIterator1                             keys_last1,
+                     InputIterator2                             keys_first2,
+                     InputIterator2                             keys_last2,
+                     InputIterator3                             values_first1,
+                     InputIterator4                             values_first2,
+                     OutputIterator1                            keys_result,
+                     OutputIterator2                            values_result);
+
+
+/*! \p set_union_by_key performs a key-value union operation from set theory.
+ *  \p set_union_by_key constructs a sorted range that is the union of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_union_by_key performs the "union" operation from set theory:
+ *  the output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt>, <tt>[keys_first2, keys_last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_union_by_key compares key elements using a function object \c comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in descending order with their values using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
+ *  int A_vals[6] = { 0,  0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {9, 7, 5, 3, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[11];
+ *  int vals_result[11];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(thrust::host, A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
+ *  // keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+ *  // vals_result is now { 0,  1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}
+ *  \endcode
+ *
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                     InputIterator1                                              keys_first1,
+                     InputIterator1                                              keys_last1,
+                     InputIterator2                                              keys_first2,
+                     InputIterator2                                              keys_last2,
+                     InputIterator3                                              values_first1,
+                     InputIterator4                                              values_first2,
+                     OutputIterator1                                             keys_result,
+                     OutputIterator2                                             values_result,
+                     StrictWeakCompare                                           comp);
+
+
+/*! \p set_union_by_key performs a key-value union operation from set theory.
+ *  \p set_union_by_key constructs a sorted range that is the union of the sorted
+ *  ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt>. Associated
+ *  with each element from the input and output key ranges is a value element. The associated input
+ *  value ranges need not be sorted.
+ *
+ *  In the simplest case, \p set_union_by_key performs the "union" operation from set theory:
+ *  the output range contains a copy of every element that is contained in
+ *  <tt>[keys_first1, keys_last1)</tt>, <tt>[keys_first2, keys_last1)</tt>, or both. The general case
+ *  is more complicated, because the input ranges may contain duplicate elements.
+ *  The generalization is that if <tt>[keys_first1, keys_last1)</tt> contains \c m elements
+ *  that are equivalent to each other and if <tt>[keys_first2, keys_last2)</tt> contains \c n
+ *  elements that are equivalent to them, then all \c m elements from the first
+ *  range shall be copied to the output range, in order, and then <tt>max(n - m, 0)</tt>
+ *  elements from the second range shall be copied to the output, in order.
+ *
+ *  Each time a key element is copied from <tt>[keys_first1, keys_last1)</tt> or
+ *  <tt>[keys_first2, keys_last2)</tt> is copied to the keys output range, the
+ *  corresponding value element is copied from the corresponding values input range (beginning at
+ *  \p values_first1 or \p values_first2) to the values output range.
+ *
+ *  This version of \p set_union_by_key compares key elements using a function object \c comp.
+ *
+ *  \param keys_first1 The beginning of the first input range of keys.
+ *  \param keys_last1 The end of the first input range of keys.
+ *  \param keys_first2 The beginning of the second input range of keys.
+ *  \param keys_last2 The end of the second input range of keys.
+ *  \param values_first1 The beginning of the first input range of values.
+ *  \param values_first2 The beginning of the first input range of values.
+ *  \param keys_result The beginning of the output range of keys.
+ *  \param values_result The beginning of the output range of values.
+ *  \param comp Comparison operator.
+ *  \return A \p pair \c p such that <tt>p.first</tt> is the end of the output range of keys,
+ *          and such that <tt>p.second</tt> is the end of the output range of values.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator1 and \p InputIterator2 have the same \c value_type,
+ *          \p InputIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator1's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator1's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          \p InputIterator2 and \p InputIterator1 have the same \c value_type,
+ *          \p InputIterator2's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          the ordering on \p InputIterator2's \c value_type is a strict weak ordering, as defined in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements,
+ *          and \p InputIterator2's \c value_type is convertable to a type in \p OutputIterator's set of \c value_types.
+ *  \tparam InputIterator3 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator3's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam InputIterator4 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator4's \c value_type is convertible to a type in \p OutputIterator2's set of \c value_types.
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam StrictWeakCompare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The ranges <tt>[keys_first1, keys_last1)</tt> and <tt>[keys_first2, keys_last2)</tt> shall be sorted with respect to \p comp.
+ *  \pre The resulting ranges shall not overlap with any input range.
+ *
+ *  The following code snippet demonstrates how to use \p set_symmetric_difference_by_key to compute the
+ *  symmetric difference of two sets of integers sorted in descending order with their values.
+ *
+ *  \code
+ *  #include <thrust/set_operations.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  int A_keys[6] = {12, 10, 8, 6, 4, 2, 0};
+ *  int A_vals[6] = { 0,  0, 0, 0, 0, 0, 0};
+ *
+ *  int B_keys[5] = {9, 7, 5, 3, 1};
+ *  int B_vals[5] = {1, 1, 1, 1, 1};
+ *
+ *  int keys_result[11];
+ *  int vals_result[11];
+ *
+ *  thrust::pair<int*,int*> end = thrust::set_symmetric_difference_by_key(A_keys, A_keys + 6, B_keys, B_keys + 5, A_vals, B_vals, keys_result, vals_result, thrust::greater<int>());
+ *  // keys_result is now {12, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+ *  // vals_result is now { 0,  1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}
+ *  \endcode
+ *
+ *  \see \p set_symmetric_difference_by_key
+ *  \see \p set_intersection_by_key
+ *  \see \p set_difference_by_key
+ *  \see \p sort_by_key
+ *  \see \p is_sorted
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakCompare>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    set_union_by_key(InputIterator1                             keys_first1,
+                     InputIterator1                             keys_last1,
+                     InputIterator2                             keys_first2,
+                     InputIterator2                             keys_last2,
+                     InputIterator3                             values_first1,
+                     InputIterator4                             values_first2,
+                     OutputIterator1                            keys_result,
+                     OutputIterator2                            values_result,
+                     StrictWeakCompare                          comp);
+
+
+/*! \} // end set_operations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/set_operations.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/shuffle.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/shuffle.h
new file mode 100644
index 0000000000000000000000000000000000000000..d95327e29ce44d5f7972ad02ff306adb85e4bf83
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/shuffle.h
@@ -0,0 +1,179 @@
+/*
+ *  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.
+ */
+
+/*! \file shuffle.h
+ *  \brief Reorders range by a uniform random permutation
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reordering
+*  \ingroup algorithms
+*
+*  \addtogroup shuffling
+*  \ingroup reordering
+*  \{
+*/
+
+
+/*! \p shuffle reorders the elements <tt>[first, last)</tt> by a uniform pseudorandom permutation, defined by
+ *  random engine \p g.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to shuffle.
+ *  \param last The end of the sequence to shuffle.
+ *  \param g A UniformRandomBitGenerator
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomIterator is a random access iterator
+ *  \tparam URBG is a uniform random bit generator
+ *
+ *  The following code snippet demonstrates how to use \p shuffle to create a random permutation
+ *  using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/shuffle.h>
+ *  #include <thrust/random.h>
+ *  #include <thrust/execution_policy.h>
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::default_random_engine g;
+ *  thrust::shuffle(thrust::host, A, A + N, g);
+ *  // A is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}
+ *  \endcode
+ *
+ *  \see \p shuffle_copy
+ */
+template <typename DerivedPolicy, typename RandomIterator, typename URBG>
+__host__ __device__ void shuffle(
+    const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+    RandomIterator first, RandomIterator last, URBG&& g);
+
+/*! \p shuffle reorders the elements <tt>[first, last)</tt> by a uniform pseudorandom permutation, defined by
+ *  random engine \p g.
+ *
+ *  \param first The beginning of the sequence to shuffle.
+ *  \param last The end of the sequence to shuffle.
+ *  \param g A UniformRandomBitGenerator
+ *
+ *  \tparam RandomIterator is a random access iterator
+ *  \tparam URBG is a uniform random bit generator
+ *
+ *  The following code snippet demonstrates how to use \p shuffle to create a random permutation.
+ *
+ *  \code
+ *  #include <thrust/shuffle.h>
+ *  #include <thrust/random.h>
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::default_random_engine g;
+ *  thrust::shuffle(A, A + N, g);
+ *  // A is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}
+ *  \endcode
+ *
+ *  \see \p shuffle_copy
+ */
+template <typename RandomIterator, typename URBG>
+__host__ __device__ void shuffle(RandomIterator first, RandomIterator last,
+                                 URBG&& g);
+
+/*! shuffle_copy differs from shuffle only in that the reordered sequence is written to different output sequences, rather than in place.
+ *  \p shuffle_copy reorders the elements <tt>[first, last)</tt> by a uniform pseudorandom permutation, defined by
+ *  random engine \p g.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to shuffle.
+ *  \param last The end of the sequence to shuffle.
+ *  \param result Destination of shuffled sequence
+ *  \param g A UniformRandomBitGenerator
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomIterator is a random access iterator
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam URBG is a uniform random bit generator
+ *
+ *  The following code snippet demonstrates how to use \p shuffle_copy to create a random permutation.
+ *
+ *  \code
+ *  #include <thrust/shuffle.h>
+ *  #include <thrust/random.h>
+ *  #include <thrust/execution_policy.h>
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::default_random_engine g;
+ *  thrust::shuffle_copy(thrust::host, A, A + N, result, g);
+ *  // result is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}
+ *  \endcode
+ *
+ *  \see \p shuffle
+ */
+template <typename DerivedPolicy, typename RandomIterator,
+          typename OutputIterator, typename URBG>
+__host__ __device__ void shuffle_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy>& exec,
+    RandomIterator first, RandomIterator last, OutputIterator result, URBG&& g);
+
+/*! shuffle_copy differs from shuffle only in that the reordered sequence is written to different output sequences, rather than in place.
+ *\p shuffle_copy reorders the elements <tt>[first, last)</tt> by a uniform pseudorandom permutation, defined by
+ *  random engine \p g.
+ *
+ *  \param first The beginning of the sequence to shuffle.
+ *  \param last The end of the sequence to shuffle.
+ *  \param result Destination of shuffled sequence
+ *  \param g A UniformRandomBitGenerator
+ *
+ *  \tparam RandomIterator is a random access iterator
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam URBG is a uniform random bit generator
+ *
+ *  The following code snippet demonstrates how to use \p shuffle_copy to create a random permutation.
+ *
+ *  \code
+ *  #include <thrust/shuffle.h>
+ *  #include <thrust/random.h>
+ *  int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ *  int result[10];
+ *  const int N = sizeof(A)/sizeof(int);
+ *  thrust::default_random_engine g;
+ *  thrust::shuffle_copy(A, A + N, result, g);
+ *  // result is now {6, 5, 8, 7, 2, 1, 4, 3, 10, 9}
+ *  \endcode
+ *
+ *  \see \p shuffle
+ */
+template <typename RandomIterator, typename OutputIterator, typename URBG>
+__host__ __device__ void shuffle_copy(RandomIterator first, RandomIterator last,
+                                      OutputIterator result, URBG&& g);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/shuffle.inl>
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cf9d6217ab0445bfc94228af6c3b76e595f2f20
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/sort.h
@@ -0,0 +1,1358 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/sort.h
+ *  \brief Functions for reorganizing ranges into sorted order
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup sorting
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p sort sorts the elements in <tt>[first, last)</tt> into
+ *  ascending order, meaning that if \c i and \c j are any two valid
+ *  iterators in <tt>[first, last)</tt> such that \c i precedes \c j,
+ *  then \c *j is not less than \c *i. Note: \c sort is not guaranteed
+ *  to be stable. That is, suppose that \c *i and \c *j are equivalent:
+ *  neither one is less than the other. It is not guaranteed that the
+ *  relative order of these two elements will be preserved by \p sort.
+ *
+ *  This version of \p sort compares objects using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *  The following code snippet demonstrates how to use \p sort to sort
+ *  a sequence of integers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(thrust::host, A, A + N);
+ *  // A is now {1, 2, 4, 5, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort
+ *  \see \p sort_by_key
+ */
+template<typename DerivedPolicy, typename RandomAccessIterator>
+__host__ __device__
+  void sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            RandomAccessIterator first,
+            RandomAccessIterator last);
+
+
+/*! \p sort sorts the elements in <tt>[first, last)</tt> into
+ *  ascending order, meaning that if \c i and \c j are any two valid
+ *  iterators in <tt>[first, last)</tt> such that \c i precedes \c j,
+ *  then \c *j is not less than \c *i. Note: \c sort is not guaranteed
+ *  to be stable. That is, suppose that \c *i and \c *j are equivalent:
+ *  neither one is less than the other. It is not guaranteed that the
+ *  relative order of these two elements will be preserved by \p sort.
+ *
+ *  This version of \p sort compares objects using \c operator<.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *  The following code snippet demonstrates how to use \p sort to sort
+ *  a sequence of integers.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(A, A + N);
+ *  // A is now {1, 2, 4, 5, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort
+ *  \see \p sort_by_key
+ */
+template<typename RandomAccessIterator>
+  void sort(RandomAccessIterator first,
+            RandomAccessIterator last);
+
+
+/*! \p sort sorts the elements in <tt>[first, last)</tt> into
+ *  ascending order, meaning that if \c i and \c j are any two valid
+ *  iterators in <tt>[first, last)</tt> such that \c i precedes \c j,
+ *  then \c *j is not less than \c *i. Note: \c sort is not guaranteed
+ *  to be stable. That is, suppose that \c *i and \c *j are equivalent:
+ *  neither one is less than the other. It is not guaranteed that the
+ *  relative order of these two elements will be preserved by \p sort.
+ *
+ *  This version of \p sort compares objects using a function object
+ *  \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param comp  Comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code demonstrates how to sort integers in descending order
+ *  using the greater<int> comparison operator using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(thrust::host, A, A + N, thrust::greater<int>());
+ *  // A is now {8, 7, 5, 4, 2, 1};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort
+ *  \see \p sort_by_key
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            RandomAccessIterator first,
+            RandomAccessIterator last,
+            StrictWeakOrdering comp);
+
+
+/*! \p sort sorts the elements in <tt>[first, last)</tt> into
+ *  ascending order, meaning that if \c i and \c j are any two valid
+ *  iterators in <tt>[first, last)</tt> such that \c i precedes \c j,
+ *  then \c *j is not less than \c *i. Note: \c sort is not guaranteed
+ *  to be stable. That is, suppose that \c *i and \c *j are equivalent:
+ *  neither one is less than the other. It is not guaranteed that the
+ *  relative order of these two elements will be preserved by \p sort.
+ *
+ *  This version of \p sort compares objects using a function object
+ *  \p comp.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param comp  Comparison operator.
+ *
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code demonstrates how to sort integers in descending order
+ *  using the greater<int> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(A, A + N, thrust::greater<int>());
+ *  // A is now {8, 7, 5, 4, 2, 1};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort
+ *  \see \p sort_by_key
+ */
+template<typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void sort(RandomAccessIterator first,
+            RandomAccessIterator last,
+            StrictWeakOrdering comp);
+
+
+/*! \p stable_sort is much like \c sort: it sorts the elements in
+ *  <tt>[first, last)</tt> into ascending order, meaning that if \c i
+ *  and \c j are any two valid iterators in <tt>[first, last)</tt> such
+ *  that \c i precedes \c j, then \c *j is not less than \c *i.
+ *
+ *  As the name suggests, \p stable_sort is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[first, last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort compares objects using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *  The following code snippet demonstrates how to use \p sort to sort
+ *  a sequence of integers using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::stable_sort(thrust::host, A, A + N);
+ *  // A is now {1, 2, 4, 5, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_sort
+ *  \see \p sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename DerivedPolicy, typename RandomAccessIterator>
+__host__ __device__
+  void stable_sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator last);
+
+
+/*! \p stable_sort is much like \c sort: it sorts the elements in
+ *  <tt>[first, last)</tt> into ascending order, meaning that if \c i
+ *  and \c j are any two valid iterators in <tt>[first, last)</tt> such
+ *  that \c i precedes \c j, then \c *j is not less than \c *i.
+ *
+ *  As the name suggests, \p stable_sort is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[first, last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort compares objects using \c operator<.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *  The following code snippet demonstrates how to use \p sort to sort
+ *  a sequence of integers.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::stable_sort(A, A + N);
+ *  // A is now {1, 2, 4, 5, 7, 8}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_sort
+ *  \see \p sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename RandomAccessIterator>
+  void stable_sort(RandomAccessIterator first,
+                   RandomAccessIterator last);
+
+
+/*! \p stable_sort is much like \c sort: it sorts the elements in
+ *  <tt>[first, last)</tt> into ascending order, meaning that if \c i
+ *  and \c j are any two valid iterators in <tt>[first, last)</tt> such
+ *  that \c i precedes \c j, then \c *j is not less than \c *i.
+ *
+ *  As the name suggests, \p stable_sort is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[first, last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort compares objects using a function object
+ *  \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code demonstrates how to sort integers in descending order
+ *  using the greater<int> comparison operator using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(A, A + N, thrust::greater<int>());
+ *  // A is now {8, 7, 5, 4, 2, 1};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_sort
+ *  \see \p sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void stable_sort(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp);
+
+
+/*! \p stable_sort is much like \c sort: it sorts the elements in
+ *  <tt>[first, last)</tt> into ascending order, meaning that if \c i
+ *  and \c j are any two valid iterators in <tt>[first, last)</tt> such
+ *  that \c i precedes \c j, then \c *j is not less than \c *i.
+ *
+ *  As the name suggests, \p stable_sort is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[first, last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort compares objects using a function object
+ *  \p comp.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam RandomAccessIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator is mutable,
+ *          and \p RandomAccessIterator's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code demonstrates how to sort integers in descending order
+ *  using the greater<int> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  const int N = 6;
+ *  int A[N] = {1, 4, 2, 8, 5, 7};
+ *  thrust::sort(A, A + N, thrust::greater<int>());
+ *  // A is now {8, 7, 5, 4, 2, 1};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/stable_sort
+ *  \see \p sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename RandomAccessIterator,
+         typename StrictWeakOrdering>
+  void stable_sort(RandomAccessIterator first,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp);
+
+
+///////////////
+// Key Value //
+///////////////
+
+
+/*! \p sort_by_key performs a key-value sort. That is, \p sort_by_key sorts the
+ *  elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  Note: \c sort_by_key is not guaranteed to be stable. That is, suppose that
+ *  \c *i and \c *j are equivalent: neither one is less than the other. It is not
+ *  guaranteed that the relative order of these two keys or the relative
+ *  order of their corresponding values will be preserved by \p sort_by_key.
+ *
+ *  This version of \p sort_by_key compares key objects using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator1's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::sort_by_key(thrust::host, keys, keys + N, values);
+ *  // keys is now   {  1,   2,   4,   5,   7,   8}
+ *  // values is now {'a', 'c', 'b', 'e', 'f', 'd'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort_by_key
+ *  \see \p sort
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+__host__ __device__
+  void sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first);
+
+
+/*! \p sort_by_key performs a key-value sort. That is, \p sort_by_key sorts the
+ *  elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  Note: \c sort_by_key is not guaranteed to be stable. That is, suppose that
+ *  \c *i and \c *j are equivalent: neither one is less than the other. It is not
+ *  guaranteed that the relative order of these two keys or the relative
+ *  order of their corresponding values will be preserved by \p sort_by_key.
+ *
+ *  This version of \p sort_by_key compares key objects using \c operator<.
+ *
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator1's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::sort_by_key(keys, keys + N, values);
+ *  // keys is now   {  1,   2,   4,   5,   7,   8}
+ *  // values is now {'a', 'c', 'b', 'e', 'f', 'd'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort_by_key
+ *  \see \p sort
+ */
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  void sort_by_key(RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first);
+
+
+/*! \p sort_by_key performs a key-value sort. That is, \p sort_by_key sorts the
+ *  elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  Note: \c sort_by_key is not guaranteed to be stable. That is, suppose that
+ *  \c *i and \c *j are equivalent: neither one is less than the other. It is not
+ *  guaranteed that the relative order of these two keys or the relative
+ *  order of their corresponding values will be preserved by \p sort_by_key.
+ *
+ *  This version of \p sort_by_key compares key objects using a function object
+ *  \c comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys using the \p thrust::host execution policy
+ *  for parallelization.The keys are sorted in descending order using the <tt>greater<int></tt> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::sort_by_key(thrust::host, keys, keys + N, values, thrust::greater<int>());
+ *  // keys is now   {  8,   7,   5,   4,   2,   1}
+ *  // values is now {'d', 'f', 'e', 'b', 'c', 'a'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort_by_key
+ *  \see \p sort
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first,
+                   StrictWeakOrdering comp);
+
+
+/*! \p sort_by_key performs a key-value sort. That is, \p sort_by_key sorts the
+ *  elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  Note: \c sort_by_key is not guaranteed to be stable. That is, suppose that
+ *  \c *i and \c *j are equivalent: neither one is less than the other. It is not
+ *  guaranteed that the relative order of these two keys or the relative
+ *  order of their corresponding values will be preserved by \p sort_by_key.
+ *
+ *  This version of \p sort_by_key compares key objects using a function object
+ *  \c comp.
+ *
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys.  The keys
+ *  are sorted in descending order using the greater<int> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::sort_by_key(keys, keys + N, values, thrust::greater<int>());
+ *  // keys is now   {  8,   7,   5,   4,   2,   1}
+ *  // values is now {'d', 'f', 'e', 'b', 'c', 'a'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p stable_sort_by_key
+ *  \see \p sort
+ */
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void sort_by_key(RandomAccessIterator1 keys_first,
+                   RandomAccessIterator1 keys_last,
+                   RandomAccessIterator2 values_first,
+                   StrictWeakOrdering comp);
+
+
+/*! \p stable_sort_by_key performs a key-value sort. That is, \p stable_sort_by_key
+ *  sorts the elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  As the name suggests, \p stable_sort_by_key is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[keys_first, keys_last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort_by_key is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort_by_key compares key objects using \c operator<.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator1's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_sort_by_key to sort
+ *  an array of characters using integers as sorting keys using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::stable_sort_by_key(thrust::host, keys, keys + N, values);
+ *  // keys is now   {  1,   2,   4,   5,   7,   8}
+ *  // values is now {'a', 'c', 'b', 'e', 'f', 'd'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+__host__ __device__
+  void stable_sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first);
+
+
+/*! \p stable_sort_by_key performs a key-value sort. That is, \p stable_sort_by_key
+ *  sorts the elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  As the name suggests, \p stable_sort_by_key is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[keys_first, keys_last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort_by_key is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort_by_key compares key objects using \c operator<.
+ *
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering relation on \p RandomAccessIterator1's \c value_type is a <em>strict weak ordering</em>, as defined in the
+ *          <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p stable_sort_by_key to sort
+ *  an array of characters using integers as sorting keys.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::stable_sort_by_key(keys, keys + N, values);
+ *  // keys is now   {  1,   2,   4,   5,   7,   8}
+ *  // values is now {'a', 'c', 'b', 'e', 'f', 'd'}
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ */
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  void stable_sort_by_key(RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first);
+
+
+/*! \p stable_sort_by_key performs a key-value sort. That is, \p stable_sort_by_key
+ *  sorts the elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  As the name suggests, \p stable_sort_by_key is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[keys_first, keys_last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort_by_key is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort_by_key compares key objects using the function
+ *  object \p comp.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys using the \p thrust::host execution policy for
+ *  parallelization. The keys are sorted in descending order using the <tt>greater<int></tt> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::stable_sort_by_key(thrust::host, keys, keys + N, values, thrust::greater<int>());
+ *  // keys is now   {  8,   7,   5,   4,   2,   1}
+ *  // values is now {'d', 'f', 'e', 'b', 'c', 'a'}
+ *  \endcode
+ *
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ */
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+__host__ __device__
+  void stable_sort_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first,
+                          StrictWeakOrdering comp);
+
+
+/*! \p stable_sort_by_key performs a key-value sort. That is, \p stable_sort_by_key
+ *  sorts the elements in <tt>[keys_first, keys_last)</tt> and <tt>[values_first,
+ *  values_first + (keys_last - keys_first))</tt> into ascending key order,
+ *  meaning that if \c i and \c j are any two valid iterators in <tt>[keys_first,
+ *  keys_last)</tt> such that \c i precedes \c j, and \c p and \c q are iterators
+ *  in <tt>[values_first, values_first + (keys_last - keys_first))</tt>
+ *  corresponding to \c i and \c j respectively, then \c *j is not less than
+ *  \c *i.
+ *
+ *  As the name suggests, \p stable_sort_by_key is stable: it preserves the
+ *  relative ordering of equivalent elements. That is, if \c x and \c y
+ *  are elements in <tt>[keys_first, keys_last)</tt> such that \c x precedes \c y,
+ *  and if the two elements are equivalent (neither <tt>x < y</tt> nor
+ *  <tt>y < x</tt>) then a postcondition of \p stable_sort_by_key is that \c x
+ *  still precedes \c y.
+ *
+ *  This version of \p stable_sort_by_key compares key objects using the function
+ *  object \p comp.
+ *
+ *  \param keys_first The beginning of the key sequence.
+ *  \param keys_last The end of the key sequence.
+ *  \param values_first The beginning of the value sequence.
+ *  \param comp Comparison operator.
+ *
+ *  \tparam RandomAccessIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/random_access_iterator">Random Access Iterator</a>,
+ *          \p RandomAccessIterator1 is mutable,
+ *          and \p RandomAccessIterator1's \c value_type is convertible to \p StrictWeakOrdering's
+ *          \c first_argument_type and \c second_argument_type.
+ *  \tparam RandomAccessIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">Random Access Iterator</a>,
+ *          and \p RandomAccessIterator2 is mutable.
+ *  \tparam StrictWeakOrdering is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last))</tt> shall not overlap the range <tt>[values_first, values_first + (keys_last - keys_first))</tt>.
+ *
+ *  The following code snippet demonstrates how to use \p sort_by_key to sort
+ *  an array of character values using integers as sorting keys.  The keys
+ *  are sorted in descending order using the greater<int> comparison operator.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  ...
+ *  const int N = 6;
+ *  int    keys[N] = {  1,   4,   2,   8,   5,   7};
+ *  char values[N] = {'a', 'b', 'c', 'd', 'e', 'f'};
+ *  thrust::stable_sort_by_key(keys, keys + N, values, thrust::greater<int>());
+ *  // keys is now   {  8,   7,   5,   4,   2,   1}
+ *  // values is now {'d', 'f', 'e', 'b', 'c', 'a'}
+ *  \endcode
+ *
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ */
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2,
+         typename StrictWeakOrdering>
+  void stable_sort_by_key(RandomAccessIterator1 keys_first,
+                          RandomAccessIterator1 keys_last,
+                          RandomAccessIterator2 values_first,
+                          StrictWeakOrdering comp);
+
+
+/*! \} // end sorting
+ */
+
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup predicates
+ *  \{
+ */
+
+
+/*! \p is_sorted returns \c true if the range <tt>[first, last)</tt> is
+ *  sorted in ascending order, and \c false otherwise.
+ *
+ *  Specifically, this version of \p is_sorted returns \c false if for
+ *  some iterator \c i in the range <tt>[first, last - 1)</tt> the
+ *  expression <tt>*(i + 1) < *i</tt> is \c true.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return \c true, if the sequence is sorted; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering on objects of \p ForwardIterator's \c value_type is a <em>strict weak ordering</em>, as defined
+ *          in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *
+ *  The following code demonstrates how to use \p is_sorted to test whether the
+ *  contents of a \c device_vector are stored in ascending order using the \p thrust::device execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(6);
+ *  v[0] = 1;
+ *  v[1] = 4;
+ *  v[2] = 2;
+ *  v[3] = 8;
+ *  v[4] = 5;
+ *  v[5] = 7;
+ *
+ *  bool result = thrust::is_sorted(thrust::device, v.begin(), v.end());
+ *
+ *  // result == false
+ *
+ *  thrust::sort(v.begin(), v.end());
+ *  result = thrust::is_sorted(thrust::device, v.begin(), v.end());
+ *
+ *  // result == true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/is_sorted
+ *  \see is_sorted_until
+ *  \see \c sort
+ *  \see \c stable_sort
+ *  \see \c less<T>
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  bool is_sorted(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last);
+
+
+/*! \p is_sorted returns \c true if the range <tt>[first, last)</tt> is
+ *  sorted in ascending order, and \c false otherwise.
+ *
+ *  Specifically, this version of \p is_sorted returns \c false if for
+ *  some iterator \c i in the range <tt>[first, last - 1)</tt> the
+ *  expression <tt>*(i + 1) < *i</tt> is \c true.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \return \c true, if the sequence is sorted; \c false, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>,
+ *          and the ordering on objects of \p ForwardIterator's \c value_type is a <em>strict weak ordering</em>, as defined
+ *          in the <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a> requirements.
+ *
+ *
+ *  The following code demonstrates how to use \p is_sorted to test whether the
+ *  contents of a \c device_vector are stored in ascending order.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/sort.h>
+ *  ...
+ *  thrust::device_vector<int> v(6);
+ *  v[0] = 1;
+ *  v[1] = 4;
+ *  v[2] = 2;
+ *  v[3] = 8;
+ *  v[4] = 5;
+ *  v[5] = 7;
+ *
+ *  bool result = thrust::is_sorted(v.begin(), v.end());
+ *
+ *  // result == false
+ *
+ *  thrust::sort(v.begin(), v.end());
+ *  result = thrust::is_sorted(v.begin(), v.end());
+ *
+ *  // result == true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/is_sorted
+ *  \see is_sorted_until
+ *  \see \c sort
+ *  \see \c stable_sort
+ *  \see \c less<T>
+ */
+template<typename ForwardIterator>
+  bool is_sorted(ForwardIterator first,
+                 ForwardIterator last);
+
+
+/*! \p is_sorted returns \c true if the range <tt>[first, last)</tt> is sorted in ascending 
+ *  order accoring to a user-defined comparison operation, and \c false otherwise.
+ *
+ *  Specifically, this version of \p is_sorted returns \c false if for some iterator \c i in
+ *  the range <tt>[first, last - 1)</tt> the expression <tt>comp(*(i + 1), *i)</tt> is \c true.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp  Comparison operator.
+ *  \return \c true, if the sequence is sorted according to comp; \c false, otherwise.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \c StrictWeakOrdering's \c first_argument_type
+ *          and \c second_argument_type.
+ *  \tparam Compare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted to test whether the
+ *  contents of a \c device_vector are stored in descending order using the \p thrust::device execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v(6);
+ *  v[0] = 1;
+ *  v[1] = 4;
+ *  v[2] = 2;
+ *  v[3] = 8;
+ *  v[4] = 5;
+ *  v[5] = 7;
+ *
+ *  thrust::greater<int> comp;
+ *  bool result = thrust::is_sorted(thrust::device, v.begin(), v.end(), comp);
+ *
+ *  // result == false
+ *
+ *  thrust::sort(v.begin(), v.end(), comp);
+ *  result = thrust::is_sorted(thrust::device, v.begin(), v.end(), comp);
+ *
+ *  // result == true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/is_sorted
+ *  \see \c sort
+ *  \see \c stable_sort
+ *  \see \c less<T>
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename Compare>
+__host__ __device__
+  bool is_sorted(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 Compare comp);
+
+
+/*! \p is_sorted returns \c true if the range <tt>[first, last)</tt> is sorted in ascending 
+ *  order accoring to a user-defined comparison operation, and \c false otherwise.
+ *
+ *  Specifically, this version of \p is_sorted returns \c false if for some iterator \c i in
+ *  the range <tt>[first, last - 1)</tt> the expression <tt>comp(*(i + 1), *i)</tt> is \c true.
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last  The end of the sequence.
+ *  \param comp  Comparison operator.
+ *  \return \c true, if the sequence is sorted according to comp; \c false, otherwise.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to both \c StrictWeakOrdering's \c first_argument_type
+ *          and \c second_argument_type.
+ *  \tparam Compare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted to test whether the
+ *  contents of a \c device_vector are stored in descending order.
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v(6);
+ *  v[0] = 1;
+ *  v[1] = 4;
+ *  v[2] = 2;
+ *  v[3] = 8;
+ *  v[4] = 5;
+ *  v[5] = 7;
+ *
+ *  thrust::greater<int> comp;
+ *  bool result = thrust::is_sorted(v.begin(), v.end(), comp);
+ *
+ *  // result == false
+ *
+ *  thrust::sort(v.begin(), v.end(), comp);
+ *  result = thrust::is_sorted(v.begin(), v.end(), comp);
+ *
+ *  // result == true
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/is_sorted
+ *  \see \c sort
+ *  \see \c stable_sort
+ *  \see \c less<T>
+ */
+template<typename ForwardIterator, typename Compare>
+  bool is_sorted(ForwardIterator first,
+                 ForwardIterator last,
+                 Compare comp);
+
+
+/*! This version of \p is_sorted_until returns the last iterator \c i in <tt>[first,last]</tt> for
+ *  which the range <tt>[first,last)</tt> is sorted using \c operator<. If <tt>distance(first,last) < 2</tt>,
+ *  \p is_sorted_until simply returns \p last.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \return The last iterator in the input range for which it is sorted.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a> and
+ *          \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted_until to find the first position
+ *  in an array where the data becomes unsorted using the \p thrust::host execution policy for
+ *  parallelization:
+ *  
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  ...
+ *   
+ *  int A[8] = {0, 1, 2, 3, 0, 1, 2, 3};
+ *  
+ *  int * B = thrust::is_sorted_until(thrust::host, A, A + 8);
+ *  
+ *  // B - A is 4
+ *  // [A, B) is sorted
+ *  \endcode
+ *
+ *  \see \p is_sorted
+ *  \see \p sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator is_sorted_until(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last);
+
+
+/*! This version of \p is_sorted_until returns the last iterator \c i in <tt>[first,last]</tt> for
+ *  which the range <tt>[first,last)</tt> is sorted using \c operator<. If <tt>distance(first,last) < 2</tt>,
+ *  \p is_sorted_until simply returns \p last.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \return The last iterator in the input range for which it is sorted.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a> and
+ *          \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/named_req/LessThanComparable">LessThan Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted_until to find the first position
+ *  in an array where the data becomes unsorted:
+ *  
+ *  \code
+ *  #include <thrust/sort.h>
+ *
+ *  ...
+ *   
+ *  int A[8] = {0, 1, 2, 3, 0, 1, 2, 3};
+ *  
+ *  int * B = thrust::is_sorted_until(A, A + 8);
+ *  
+ *  // B - A is 4
+ *  // [A, B) is sorted
+ *  \endcode
+ *
+ *  \see \p is_sorted
+ *  \see \p sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename ForwardIterator>
+  ForwardIterator is_sorted_until(ForwardIterator first,
+                                  ForwardIterator last);
+
+
+/*! This version of \p is_sorted_until returns the last iterator \c i in <tt>[first,last]</tt> for
+ *  which the range <tt>[first,last)</tt> is sorted using the function object \c comp. If <tt>distance(first,last) < 2</tt>,
+ *  \p is_sorted_until simply returns \p last.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization:
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param comp The function object to use for comparison.
+ *  \return The last iterator in the input range for which it is sorted.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a> and
+ *          \p ForwardIterator's \c value_type is convertible to \p Compare's \c argument_type.
+ *  \tparam Compare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted_until to find the first position
+ *  in an array where the data becomes unsorted in descending order using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  ...
+ *   
+ *  int A[8] = {3, 2, 1, 0, 3, 2, 1, 0};
+ *  
+ *  thrust::greater<int> comp;
+ *  int * B = thrust::is_sorted_until(thrust::host, A, A + 8, comp);
+ *  
+ *  // B - A is 4
+ *  // [A, B) is sorted in descending order
+ *  \endcode
+ *
+ *  \see \p is_sorted
+ *  \see \p sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename Compare>
+__host__ __device__
+  ForwardIterator is_sorted_until(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last,
+                                  Compare comp);
+
+
+/*! This version of \p is_sorted_until returns the last iterator \c i in <tt>[first,last]</tt> for
+ *  which the range <tt>[first,last)</tt> is sorted using the function object \c comp. If <tt>distance(first,last) < 2</tt>,
+ *  \p is_sorted_until simply returns \p last.
+ *
+ *  \param first The beginning of the range of interest.
+ *  \param last The end of the range of interest.
+ *  \param comp The function object to use for comparison.
+ *  \return The last iterator in the input range for which it is sorted.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a> and
+ *          \p ForwardIterator's \c value_type is convertible to \p Compare's \c argument_type.
+ *  \tparam Compare is a model of <a href="https://en.cppreference.com/w/cpp/concepts/strict_weak_order">Strict Weak Ordering</a>.
+ *
+ *  The following code snippet demonstrates how to use \p is_sorted_until to find the first position
+ *  in an array where the data becomes unsorted in descending order:
+ *
+ *  \code
+ *  #include <thrust/sort.h>
+ *  #include <thrust/functional.h>
+ *
+ *  ...
+ *   
+ *  int A[8] = {3, 2, 1, 0, 3, 2, 1, 0};
+ *  
+ *  thrust::greater<int> comp;
+ *  int * B = thrust::is_sorted_until(A, A + 8, comp);
+ *  
+ *  // B - A is 4
+ *  // [A, B) is sorted in descending order
+ *  \endcode
+ *
+ *  \see \p is_sorted
+ *  \see \p sort
+ *  \see \p sort_by_key
+ *  \see \p stable_sort
+ *  \see \p stable_sort_by_key
+ */
+template<typename ForwardIterator, typename Compare>
+  ForwardIterator is_sorted_until(ForwardIterator first,
+                                  ForwardIterator last,
+                                  Compare comp);
+
+
+/*! \} // end predicates
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/sort.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8a8be73c3111390cc20c6e45089a04969e73af1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/swap.h
@@ -0,0 +1,184 @@
+/*
+ *  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 swap.h
+ *  \brief Functions for swapping the value of elements
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup swap
+ *  \{
+ */
+
+/*! \p swap assigns the contents of \c a to \c b and the
+ *  contents of \c b to \c a. This is used as a primitive operation
+ *  by many other algorithms.
+ *  
+ *  \param a The first value of interest. After completion,
+ *           the value of b will be returned here.
+ *  \param b The second value of interest. After completion,
+ *           the value of a will be returned here.
+ *
+ *  \tparam Assignable is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p swap to
+ *  swap the contents of two variables.
+ *
+ *  \code
+ *  #include <thrust/swap.h>
+ *  ...
+ *  int x = 1;
+ *  int y = 2;
+ *  thrust::swap(x,h);
+ *
+ *  // x == 2, y == 1
+ *  \endcode
+ */
+template<typename Assignable1, typename Assignable2>
+__host__ __device__ 
+inline void swap(Assignable1 &a, Assignable2 &b);
+
+/*! \} // swap
+ */
+
+/*! \} // utility
+ */
+
+
+/*! \addtogroup copying
+ *  \{
+ */
+
+
+/*! \p swap_ranges swaps each of the elements in the range <tt>[first1, last1)</tt>
+ *  with the corresponding element in the range <tt>[first2, first2 + (last1 - first1))</tt>.
+ *  That is, for each integer \c n such that <tt>0 <= n < (last1 - first1)</tt>, it swaps
+ *  <tt>*(first1 + n)</tt> and <tt>*(first2 + n)</tt>. The return value is
+ *  <tt>first2 + (last1 - first1)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first sequence to swap.
+ *  \param last1 One position past the last element of the first sequence to swap.
+ *  \param first2 The beginning of the second sequence to swap.
+ *  \return An iterator pointing to one position past the last element of the second
+ *          sequence to swap.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1's \c value_type must be convertible to \p ForwardIterator2's \c value_type.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2's \c value_type must be convertible to \p ForwardIterator1's \c value_type.
+ *
+ *  \pre \p first1 may equal \p first2, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[first2, first2 + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p swap_ranges to
+ *  swap the contents of two \c thrust::device_vectors using the \p thrust::device execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/swap.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  thrust::device_vector<int> v1(2), v2(2);
+ *  v1[0] = 1;
+ *  v1[1] = 2;
+ *  v2[0] = 3;
+ *  v2[1] = 4;
+ *
+ *  thrust::swap_ranges(thrust::device, v1.begin(), v1.end(), v2.begin());
+ *
+ *  // v1[0] == 3, v1[1] == 4, v2[0] == 1, v2[1] == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/swap_ranges
+ *  \see \c swap
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__host__ __device__
+  ForwardIterator2 swap_ranges(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               ForwardIterator1 first1,
+                               ForwardIterator1 last1,
+                               ForwardIterator2 first2);
+
+
+/*! \p swap_ranges swaps each of the elements in the range <tt>[first1, last1)</tt>
+ *  with the corresponding element in the range <tt>[first2, first2 + (last1 - first1))</tt>.
+ *  That is, for each integer \c n such that <tt>0 <= n < (last1 - first1)</tt>, it swaps
+ *  <tt>*(first1 + n)</tt> and <tt>*(first2 + n)</tt>. The return value is
+ *  <tt>first2 + (last1 - first1)</tt>.
+ *
+ *  \param first1 The beginning of the first sequence to swap.
+ *  \param last1 One position past the last element of the first sequence to swap.
+ *  \param first2 The beginning of the second sequence to swap.
+ *  \return An iterator pointing to one position past the last element of the second
+ *          sequence to swap.
+ *
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1's \c value_type must be convertible to \p ForwardIterator2's \c value_type.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2's \c value_type must be convertible to \p ForwardIterator1's \c value_type.
+ *
+ *  \pre \p first1 may equal \p first2, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[first2, first2 + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p swap_ranges to
+ *  swap the contents of two \c thrust::device_vectors.
+ *
+ *  \code
+ *  #include <thrust/swap.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> v1(2), v2(2);
+ *  v1[0] = 1;
+ *  v1[1] = 2;
+ *  v2[0] = 3;
+ *  v2[1] = 4;
+ *
+ *  thrust::swap_ranges(v1.begin(), v1.end(), v2.begin());
+ *
+ *  // v1[0] == 3, v1[1] == 4, v2[0] == 1, v2[1] == 2
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/swap_ranges
+ *  \see \c swap
+ */
+template<typename ForwardIterator1,
+         typename ForwardIterator2>
+  ForwardIterator2 swap_ranges(ForwardIterator1 first1,
+                               ForwardIterator1 last1,
+                               ForwardIterator2 first2);
+
+
+/*! \} // copying
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/swap.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/adjacent_difference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/adjacent_difference.h
new file mode 100644
index 0000000000000000000000000000000000000000..b82242c7c0798b58c6d2c2d3da12770dd373d562
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/adjacent_difference.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits adjacent_difference
+#include <thrust/system/detail/sequential/adjacent_difference.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/assign_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/assign_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5f14bd1636df4a18e36906fb34842a1efc56f66
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/assign_value.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits assign_value
+#include <thrust/system/detail/sequential/assign_value.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/binary_search.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/binary_search.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2c33f32aad3991ba000f095b20e635a0844f718
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/binary_search.h
@@ -0,0 +1,23 @@
+/*
+ *  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/system/cpp/detail/execution_policy.h>
+
+// this system inherits the binary search algorithms
+#include <thrust/system/detail/sequential/binary_search.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2f5b1bd45cd777827137f2d7e9b885ec9fd9c34
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits copy
+#include <thrust/system/detail/sequential/copy.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy_if.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy_if.h
new file mode 100644
index 0000000000000000000000000000000000000000..10869e2a90215ecf1045b36882180acf3e791981
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/copy_if.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits copy_if
+#include <thrust/system/detail/sequential/copy_if.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/count.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/count.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/equal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/equal.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/equal.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a8193bf3acf4aafe1a0ffe5134d94f934889906
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/execution_policy.h
@@ -0,0 +1,80 @@
+/*
+ *  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>
+#include <thrust/system/detail/sequential/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+// put the canonical tag in the same ns as the backend's entry points
+namespace cpp
+{
+namespace detail
+{
+
+// this awkward sequence of definitions arise
+// from the desire both for tag to derive
+// from execution_policy and for execution_policy
+// to convert to tag (when execution_policy is not
+// an ancestor of tag)
+
+// forward declaration of tag
+struct tag;
+
+// forward declaration of execution_policy
+template<typename> struct execution_policy;
+
+// specialize execution_policy for tag
+template<>
+  struct execution_policy<tag>
+    : thrust::system::detail::sequential::execution_policy<tag>
+{};
+
+// tag's definition comes before the
+// generic definition of execution_policy
+struct tag : execution_policy<tag> {};
+
+// allow conversion to tag when it is not a successor
+template<typename Derived>
+  struct execution_policy
+    : thrust::system::detail::sequential::execution_policy<Derived>
+{
+  typedef tag tag_type; 
+  operator tag() const { return tag(); }
+};
+
+} // end detail
+
+// alias execution_policy and tag here
+using thrust::system::cpp::detail::execution_policy;
+using thrust::system::cpp::detail::tag;
+
+} // end cpp
+} // end system
+
+// alias items at top-level
+namespace cpp
+{
+
+using thrust::system::cpp::execution_policy;
+using thrust::system::cpp::tag;
+
+} // end cpp
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/extrema.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/extrema.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fbb8c55c287cb15330d991376c3c10d75829f25
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/extrema.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits extrema algorithms
+#include <thrust/system/detail/sequential/extrema.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/fill.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/find.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/find.h
new file mode 100644
index 0000000000000000000000000000000000000000..29c0dafc8ceea556c99666b7cdf22d07f5b458bd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/find.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits find
+#include <thrust/system/detail/sequential/find.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ef45dfe62e47d9779c4b60839628efd82c2a5e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/for_each.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits for_each
+#include <thrust/system/detail/sequential/for_each.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/gather.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/gather.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/generate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/generate.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/generate.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/get_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/get_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..915001d37f4dba8a6173df49f635b50f88ef162d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/get_value.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits get_value
+#include <thrust/system/detail/sequential/get_value.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/inner_product.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/inner_product.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/inner_product.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/iter_swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/iter_swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a982becb3949b2229bbf4bbf3fcc40f20f34253
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/iter_swap.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits iter_swap
+#include <thrust/system/detail/sequential/iter_swap.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/logical.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/logical.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/logical.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/malloc_and_free.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/malloc_and_free.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1ad7a7341bf701b7f333033059c18b98096c2d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/malloc_and_free.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits malloc & free
+#include <thrust/system/detail/sequential/malloc_and_free.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/memory.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/memory.inl
new file mode 100644
index 0000000000000000000000000000000000000000..650aa1cb50167d668bdef8784b6a9717f842b2e5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/memory.inl
@@ -0,0 +1,52 @@
+/*
+ *  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>
+#include <thrust/system/cpp/memory.h>
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+pointer<void> malloc(std::size_t n)
+{
+  tag t;
+  return pointer<void>(thrust::system::detail::sequential::malloc(t, n));
+} // end malloc()
+
+template<typename T>
+pointer<T> malloc(std::size_t n)
+{
+  pointer<void> raw_ptr = thrust::system::cpp::malloc(sizeof(T) * n);
+  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
+} // end malloc()
+
+void free(pointer<void> ptr)
+{
+  tag t;
+  return thrust::system::detail::sequential::free(t, ptr);
+} // end free()
+
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/merge.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/merge.h
new file mode 100644
index 0000000000000000000000000000000000000000..20e17f2d40dd218d2e7b22a7744321f75ea6ab0c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/merge.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits merge
+#include <thrust/system/detail/sequential/merge.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/mismatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/mismatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/mismatch.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/par.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/par.h
new file mode 100644
index 0000000000000000000000000000000000000000..c56921327f5e76b5d202d852d005879e71407a16
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/par.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
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/allocator_aware_execution_policy.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+namespace detail
+{
+
+
+struct par_t : thrust::system::cpp::detail::execution_policy<par_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    thrust::system::cpp::detail::execution_policy>
+{
+  __host__ __device__
+  constexpr par_t() : thrust::system::cpp::detail::execution_policy<par_t>() {}
+};
+
+
+} // end detail
+
+
+THRUST_INLINE_CONSTANT detail::par_t par;
+
+
+} // end cpp
+} // end system
+
+
+// alias par here
+namespace cpp
+{
+
+
+using thrust::system::cpp::par;
+
+
+} // end cpp
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/partition.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/partition.h
new file mode 100644
index 0000000000000000000000000000000000000000..50d48e222aa53424d0fcdf8b2bc3e8bf4a9f4e54
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/partition.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits partition
+#include <thrust/system/detail/sequential/partition.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/per_device_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/per_device_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b8d61f92169e0e09c3821e59218f0dcbb70cbe5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/per_device_resource.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special per device resource functions
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..e09652cd9fd6a30fd1673d1bbd33313b23450a3f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits reduce
+#include <thrust/system/detail/sequential/reduce.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2c7744249bdd644f2c8bf8e4d8b86bb583ac332
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reduce_by_key.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits reduce_by_key
+#include <thrust/system/detail/sequential/reduce_by_key.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/remove.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/remove.h
new file mode 100644
index 0000000000000000000000000000000000000000..a529f625d6a206ec684f5c08f9fd8c199e5fcba4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/remove.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits remove
+#include <thrust/system/detail/sequential/remove.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/replace.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/replace.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/replace.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reverse.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reverse.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/reverse.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d38e648437322d078d49c9412ab9532b7cc8b69
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits scan
+#include <thrust/system/detail/sequential/scan.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e72e7c38f868bb83bc835c3d627751c54e2cd15
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scan_by_key.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits the scan_by_key algorithms
+#include <thrust/system/detail/sequential/scan_by_key.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scatter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/scatter.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sequence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sequence.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/set_operations.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/set_operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbde20114c2c8348ceff8dfb226f7e5ed71cc026
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/set_operations.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits the set operations
+#include <thrust/system/detail/sequential/set_operations.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae38b3ba8c7854eafc92fe9f35ff7d3220a02c20
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/sort.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits sort
+#include <thrust/system/detail/sequential/sort.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/swap_ranges.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/swap_ranges.h
new file mode 100644
index 0000000000000000000000000000000000000000..35cd5462207a0a9d02cdfad9be9730f74a511e82
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/swap_ranges.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// cpp has no special swap_ranges
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/tabulate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/tabulate.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/tabulate.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/temporary_buffer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/temporary_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..2adfaf2810c67462e41f271e43ad0aff9cfbf75f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/temporary_buffer.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special temporary buffer functions
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..895164ce5afbc15c1ceff3a921d3b3765e99f251
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// cpp has no special transform
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_reduce.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/transform_scan.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_copy.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/uninitialized_fill.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique.h
new file mode 100644
index 0000000000000000000000000000000000000000..2ff23e9d3db060d3284c743a1178b20069026575
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits unique
+#include <thrust/system/detail/sequential/unique.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d40011787cb8eaea25a969c855c1c758a0225e4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/unique_by_key.h
@@ -0,0 +1,23 @@
+/*
+ *  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>
+
+// this system inherits unique_by_key
+#include <thrust/system/detail/sequential/unique_by_key.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/vector.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/vector.inl
new file mode 100644
index 0000000000000000000000000000000000000000..02980c62a429a94fc50b429157651a3e7bd5fc32
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/detail/vector.inl
@@ -0,0 +1,146 @@
+/*
+ *  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>
+#include <thrust/system/cpp/vector.h>
+#include <utility>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector()
+      : super_t()
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(size_type n)
+      : super_t(n)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(size_type n, const value_type &value)
+      : super_t(n,value)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator>
+    ::vector(const vector &x)
+      : super_t(x)
+{}
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(vector &&x)
+        : super_t(std::move(x))
+  {}
+#endif
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator>
+      ::vector(const thrust::detail::vector_base<OtherT,OtherAllocator> &x)
+        : super_t(x)
+{}
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator>
+      ::vector(const std::vector<OtherT,OtherAllocator> &x)
+        : super_t(x)
+{}
+
+template<typename T, typename Allocator>
+  template<typename InputIterator>
+    vector<T,Allocator>
+      ::vector(InputIterator first, InputIterator last)
+        : super_t(first,last)
+{}
+
+template<typename T, typename Allocator>
+  vector<T,Allocator> &
+    vector<T,Allocator>
+      ::operator=(const vector &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+  template<typename T, typename Allocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(vector &&x)
+  {
+    super_t::operator=(std::move(x));
+    return *this;
+  }
+#endif
+  
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(std::initializer_list<T> il)
+        : super_t(il)
+  {}
+  
+  template<typename T, typename Allocator>
+    vector<T,Allocator>
+      ::vector(std::initializer_list<T> il, const Allocator& alloc)
+        : super_t(il, alloc)
+  {}
+
+  template<typename T, typename Allocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(std::initializer_list<T> il)
+  {
+    super_t::operator=(il);
+    return *this;
+  }
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(const std::vector<OtherT,OtherAllocator> &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+
+template<typename T, typename Allocator>
+  template<typename OtherT, typename OtherAllocator>
+    vector<T,Allocator> &
+      vector<T,Allocator>
+        ::operator=(const thrust::detail::vector_base<OtherT,OtherAllocator> &x)
+{
+  super_t::operator=(x);
+  return *this;
+}
+      
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d8a9a36790b6c71cb67170a0ba426ac6aa1e4cf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/execution_policy.h
@@ -0,0 +1,156 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/system/cpp/execution_policy.h
+ *  \brief Execution policies for Thrust's Standard C++ system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// get the execution policies definitions first
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+// get the definition of par
+#include <thrust/system/cpp/detail/par.h>
+
+// now get all the algorithm definitions
+
+#include <thrust/system/cpp/detail/adjacent_difference.h>
+#include <thrust/system/cpp/detail/assign_value.h>
+#include <thrust/system/cpp/detail/binary_search.h>
+#include <thrust/system/cpp/detail/copy.h>
+#include <thrust/system/cpp/detail/copy_if.h>
+#include <thrust/system/cpp/detail/count.h>
+#include <thrust/system/cpp/detail/equal.h>
+#include <thrust/system/cpp/detail/extrema.h>
+#include <thrust/system/cpp/detail/fill.h>
+#include <thrust/system/cpp/detail/find.h>
+#include <thrust/system/cpp/detail/for_each.h>
+#include <thrust/system/cpp/detail/gather.h>
+#include <thrust/system/cpp/detail/generate.h>
+#include <thrust/system/cpp/detail/get_value.h>
+#include <thrust/system/cpp/detail/inner_product.h>
+#include <thrust/system/cpp/detail/iter_swap.h>
+#include <thrust/system/cpp/detail/logical.h>
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+#include <thrust/system/cpp/detail/merge.h>
+#include <thrust/system/cpp/detail/mismatch.h>
+#include <thrust/system/cpp/detail/partition.h>
+#include <thrust/system/cpp/detail/reduce.h>
+#include <thrust/system/cpp/detail/reduce_by_key.h>
+#include <thrust/system/cpp/detail/remove.h>
+#include <thrust/system/cpp/detail/replace.h>
+#include <thrust/system/cpp/detail/reverse.h>
+#include <thrust/system/cpp/detail/scan.h>
+#include <thrust/system/cpp/detail/scan_by_key.h>
+#include <thrust/system/cpp/detail/scatter.h>
+#include <thrust/system/cpp/detail/sequence.h>
+#include <thrust/system/cpp/detail/set_operations.h>
+#include <thrust/system/cpp/detail/sort.h>
+#include <thrust/system/cpp/detail/swap_ranges.h>
+#include <thrust/system/cpp/detail/tabulate.h>
+#include <thrust/system/cpp/detail/transform.h>
+#include <thrust/system/cpp/detail/transform_reduce.h>
+#include <thrust/system/cpp/detail/transform_scan.h>
+#include <thrust/system/cpp/detail/uninitialized_copy.h>
+#include <thrust/system/cpp/detail/uninitialized_fill.h>
+#include <thrust/system/cpp/detail/unique.h>
+#include <thrust/system/cpp/detail/unique_by_key.h>
+
+
+// define these entities here for the purpose of Doxygenating them
+// they are actually defined elsewhere
+#if 0
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cpp
+{
+
+
+/*! \addtogroup execution_policies
+ *  \{
+ */
+
+
+/*! \p thrust::system::cpp::execution_policy is the base class for all Thrust parallel execution
+ *  policies which are derived from Thrust's standard C++ backend system.
+ */
+template<typename DerivedPolicy>
+struct execution_policy : thrust::execution_policy<DerivedPolicy>
+{};
+
+
+/*! \p thrust::system::cpp::tag is a type representing Thrust's standard C++ backend system in C++'s type system.
+ *  Iterators "tagged" with a type which is convertible to \p cpp::tag assert that they may be
+ *  "dispatched" to algorithm implementations in the \p cpp system.
+ */
+struct tag : thrust::system::cpp::execution_policy<tag> { unspecified };
+
+
+/*!
+ *  \p thrust::system::cpp::par is the parallel execution policy associated with Thrust's standard
+ *  C++ backend system.
+ *
+ *  Instead of relying on implicit algorithm dispatch through iterator system tags, users may
+ *  directly target Thrust's C++ backend system by providing \p thrust::cpp::par as an algorithm
+ *  parameter.
+ *
+ *  Explicit dispatch can be useful in avoiding the introduction of data copies into containers such
+ *  as \p thrust::cpp::vector.
+ *
+ *  The type of \p thrust::cpp::par is implementation-defined.
+ *
+ *  The following code snippet demonstrates how to use \p thrust::cpp::par to explicitly dispatch an
+ *  invocation of \p thrust::for_each to the standard C++ backend system:
+ *
+ *  \code
+ *  #include <thrust/for_each.h>
+ *  #include <thrust/system/cpp/execution_policy.h>
+ *  #include <cstdio>
+ *
+ *  struct printf_functor
+ *  {
+ *    __host__ __device__
+ *    void operator()(int x)
+ *    {
+ *      printf("%d\n", x);
+ *    }
+ *  };
+ *  ...
+ *  int vec[3];
+ *  vec[0] = 0; vec[1] = 1; vec[2] = 2;
+ *
+ *  thrust::for_each(thrust::cpp::par, vec.begin(), vec.end(), printf_functor());
+ *
+ *  // 0 1 2 is printed to standard output in some unspecified order
+ *  \endcode
+ */
+static const unspecified par;
+
+
+/*! \}
+ */
+
+
+} // end cpp
+} // end system
+THRUST_NAMESPACE_END
+#endif
+
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..a18abeb8e4f5ab0aaae690fc5fb0eb02943ffcce
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory.h
@@ -0,0 +1,100 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/system/cpp/memory.h
+ *  \brief Managing memory associated with Thrust's Standard C++ system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cpp/memory_resource.h>
+#include <thrust/memory.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/mr/allocator.h>
+#include <ostream>
+
+THRUST_NAMESPACE_BEGIN
+namespace system { namespace cpp
+{
+
+/*! Allocates an area of memory available to Thrust's <tt>cpp</tt> system.
+ *  \param n Number of bytes to allocate.
+ *  \return A <tt>cpp::pointer<void></tt> pointing to the beginning of the newly
+ *          allocated memory. A null <tt>cpp::pointer<void></tt> is returned if
+ *          an error occurs.
+ *  \note The <tt>cpp::pointer<void></tt> returned by this function must be
+ *        deallocated with \p cpp::free.
+ *  \see cpp::free
+ *  \see std::malloc
+ */
+inline pointer<void> malloc(std::size_t n);
+
+/*! Allocates a typed area of memory available to Thrust's <tt>cpp</tt> system.
+ *  \param n Number of elements to allocate.
+ *  \return A <tt>cpp::pointer<T></tt> pointing to the beginning of the newly
+ *          allocated elements. A null <tt>cpp::pointer<T></tt> is returned if
+ *          an error occurs.
+ *  \note The <tt>cpp::pointer<T></tt> returned by this function must be
+ *        deallocated with \p cpp::free.
+ *  \see cpp::free
+ *  \see std::malloc
+ */
+template<typename T>
+inline pointer<T> malloc(std::size_t n);
+
+/*! Deallocates an area of memory previously allocated by <tt>cpp::malloc</tt>.
+ *  \param ptr A <tt>cpp::pointer<void></tt> pointing to the beginning of an area
+ *         of memory previously allocated with <tt>cpp::malloc</tt>.
+ *  \see cpp::malloc
+ *  \see std::free
+ */
+inline void free(pointer<void> ptr);
+
+/*! \p cpp::allocator is the default allocator used by the \p cpp system's
+ *  containers such as <tt>cpp::vector</tt> if no user-specified allocator is
+ *  provided. \p cpp::allocator allocates (deallocates) storage with \p
+ *  cpp::malloc (\p cpp::free).
+ */
+template<typename T>
+using allocator = thrust::mr::stateless_resource_allocator<
+  T, thrust::system::cpp::memory_resource
+>;
+
+/*! \p cpp::universal_allocator allocates memory that can be used by the \p cpp
+ *  system and host systems.
+ */
+template<typename T>
+using universal_allocator = thrust::mr::stateless_resource_allocator<
+  T, thrust::system::cpp::universal_memory_resource
+>;
+
+}} // namespace system::cpp
+
+/*! \namespace thrust::cpp
+ *  \brief \p thrust::cpp is a top-level alias for thrust::system::cpp.
+ */
+namespace cpp
+{
+using thrust::system::cpp::malloc;
+using thrust::system::cpp::free;
+using thrust::system::cpp::allocator;
+} // namespace cpp
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cpp/detail/memory.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..04b4e3cf8dab837d169f0baab272ad9db87297f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/memory_resource.h
@@ -0,0 +1,71 @@
+/*
+ *  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.
+ */
+
+/*! \file cpp/memory_resource.h
+ *  \brief Memory resources for the Standard C++ system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/mr/new.h>
+#include <thrust/mr/fancy_pointer_resource.h>
+
+#include <thrust/system/cpp/pointer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system { namespace cpp
+{
+
+//! \cond
+namespace detail
+{
+    typedef thrust::mr::fancy_pointer_resource<
+        thrust::mr::new_delete_resource,
+        thrust::cpp::pointer<void>
+    > native_resource;
+
+    typedef thrust::mr::fancy_pointer_resource<
+        thrust::mr::new_delete_resource,
+        thrust::cpp::universal_pointer<void>
+    > universal_native_resource;
+} // namespace detail
+//! \endcond
+
+/*! \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management
+ *  \{
+ */
+
+/*! The memory resource for the Standard C++ system. Uses \p
+ *  mr::new_delete_resource and tags it with \p cpp::pointer.
+ */
+typedef detail::native_resource memory_resource;
+/*! The unified memory resource for the Standard C++ system. Uses
+ *  \p mr::new_delete_resource and tags it with \p cpp::universal_pointer.
+ */
+typedef detail::universal_native_resource universal_memory_resource;
+/*! An alias for \p cpp::universal_memory_resource. */
+typedef detail::native_resource universal_host_pinned_memory_resource;
+
+/*! \} // memory_resources
+ */
+
+
+}} // namespace system::cpp
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/pointer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/pointer.h
new file mode 100644
index 0000000000000000000000000000000000000000..f204fa37509e46b37ea5f556a029c601c0b61820
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/pointer.h
@@ -0,0 +1,117 @@
+/*
+ *  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.
+ */
+
+/*! \file thrust/system/cpp/memory.h
+ *  \brief Managing memory associated with Thrust's TBB system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <type_traits>
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/reference.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system { namespace cpp
+{
+
+/*! \p cpp::pointer stores a pointer to an object allocated in memory accessible
+ *  by the \p cpp system. This type provides type safety when dispatching
+ *  algorithms on ranges resident in \p cpp memory.
+ *
+ *  \p cpp::pointer has pointer semantics: it may be dereferenced and
+ *  manipulated with pointer arithmetic.
+ *
+ *  \p cpp::pointer can be created with the function \p cpp::malloc, or by
+ *  explicitly calling its constructor with a raw pointer.
+ *
+ *  The raw pointer encapsulated by a \p cpp::pointer may be obtained by eiter its
+ *  <tt>get</tt> member function or the \p raw_pointer_cast function.
+ *
+ *  \note \p cpp::pointer is not a "smart" pointer; it is the programmer's
+ *        responsibility to deallocate memory pointed to by \p cpp::pointer.
+ *
+ *  \tparam T specifies the type of the pointee.
+ *
+ *  \see cpp::malloc
+ *  \see cpp::free
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+using pointer = thrust::pointer<
+  T,
+  thrust::system::cpp::tag,
+  thrust::tagged_reference<T, thrust::system::cpp::tag>
+>;
+
+/*! \p cpp::universal_pointer stores a pointer to an object allocated in memory
+ * accessible by the \p cpp system and host systems.
+ *
+ *  \p cpp::universal_pointer has pointer semantics: it may be dereferenced and
+ *  manipulated with pointer arithmetic.
+ *
+ *  \p cpp::universal_pointer can be created with \p cpp::universal_allocator
+ *  or by explicitly calling its constructor with a raw pointer.
+ *
+ *  The raw pointer encapsulated by a \p cpp::universal_pointer may be obtained
+ *  by eiter its <tt>get</tt> member function or the \p raw_pointer_cast
+ *  function.
+ *
+ *  \note \p cpp::universal_pointer is not a "smart" pointer; it is the
+ *        programmer's responsibility to deallocate memory pointed to by
+ *        \p cpp::universal_pointer.
+ *
+ *  \tparam T specifies the type of the pointee.
+ *
+ *  \see cpp::universal_allocator
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+using universal_pointer = thrust::pointer<
+  T,
+  thrust::system::cpp::tag,
+  typename std::add_lvalue_reference<T>::type
+>;
+
+/*! \p reference is a wrapped reference to an object stored in memory available
+ *  to the \p cpp system. \p reference is the type of the result of
+ *  dereferencing a \p cpp::pointer.
+ *
+ *  \tparam T Specifies the type of the referenced object.
+ */
+template <typename T>
+using reference = thrust::reference<T, thrust::system::cpp::tag>;
+
+}} // namespace system::cpp
+
+/*! \addtogroup system_backends Systems
+ *  \ingroup system
+ *  \{
+ */
+
+/*! \namespace thrust::cpp
+ *  \brief \p thrust::cpp is a top-level alias for \p thrust::system::cpp. */
+namespace cpp
+{
+using thrust::system::cpp::pointer;
+using thrust::system::cpp::universal_pointer;
+using thrust::system::cpp::reference;
+} // namespace cpp
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/vector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a418dbc30d4d1d5db592e90237b160728519cef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cpp/vector.h
@@ -0,0 +1,82 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/system/cpp/vector.h
+ *  \brief A dynamically-sizable array of elements which reside in memory available to
+ *         Thrust's standard C++ system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cpp/memory.h>
+#include <thrust/detail/vector_base.h>
+#include <vector>
+
+THRUST_NAMESPACE_BEGIN
+namespace system { namespace cpp
+{
+
+/*! \p cpp::vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p cpp::vector may vary dynamically; memory management is
+ *  automatic. The elements contained in a \p cpp::vector reside in memory
+ *  accessible by the \p cpp system.
+ *
+ *  \tparam T The element type of the \p cpp::vector.
+ *  \tparam Allocator The allocator type of the \p cpp::vector.
+ *          Defaults to \p cpp::allocator.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see host_vector For the documentation of the complete interface which is
+ *                   shared by \p cpp::vector.
+ *  \see device_vector
+ *  \see universal_vector
+ */
+template <typename T, typename Allocator = thrust::system::cpp::allocator<T>>
+using vector = thrust::detail::vector_base<T, Allocator>;
+
+/*! \p cpp::universal_vector is a container that supports random access to
+ *  elements, constant time removal of elements at the end, and linear time
+ *  insertion and removal of elements at the beginning or in the middle. The
+ *  number of elements in a \p cpp::universal_vector may vary dynamically;
+ *  memory management is automatic. The elements contained in a
+ *  \p cpp::universal_vector reside in memory accessible by the \p cpp system
+ *  and host systems.
+ *
+ *  \tparam T The element type of the \p cpp::universal_vector.
+ *  \tparam Allocator The allocator type of the \p cpp::universal_vector.
+ *          Defaults to \p cpp::universal_allocator.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see host_vector For the documentation of the complete interface which is
+ *                   shared by \p cpp::universal_vector
+ *  \see device_vector
+ *  \see universal_vector
+ */
+template <typename T, typename Allocator = thrust::system::cpp::universal_allocator<T>>
+using universal_vector = thrust::detail::vector_base<T, Allocator>;
+
+}} // namespace system::cpp
+
+namespace cpp
+{
+using thrust::system::cpp::vector;
+using thrust::system::cpp::universal_vector;
+}
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/config.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..f6c8b9cb38d69c705e05a837d6648224121bdd71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/config.h
@@ -0,0 +1,146 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+
+#ifdef THRUST_DEBUG_SYNC
+#define THRUST_DEBUG_SYNC_FLAG true
+#define CUB_DEBUG_SYNC
+#else
+#define THRUST_DEBUG_SYNC_FLAG false
+#endif
+
+
+#include <thrust/detail/config.h>
+
+// We don't directly include <cub/version.cuh> since it doesn't exist in
+// older releases. This header will always pull in version info:
+#include <cub/util_namespace.cuh>
+#include <cub/util_debug.cuh>
+
+#include <cub/detail/detect_cuda_runtime.cuh>
+
+/**
+ * \def THRUST_RUNTIME_FUNCTION
+ *
+ * Execution space for functions that can use the CUDA runtime API (`__host__`
+ * when RDC is off, `__host__ __device__` when RDC is on).
+ */
+#define THRUST_RUNTIME_FUNCTION CUB_RUNTIME_FUNCTION
+
+/**
+ * \def THRUST_RDC_ENABLED
+ *
+ * Defined if RDC is enabled.
+ */
+#ifdef CUB_RDC_ENABLED
+#define THRUST_RDC_ENABLED
+#endif
+
+/**
+ * \def __THRUST_HAS_CUDART__
+ *
+ * Whether or not the active compiler pass is allowed to invoke device kernels
+ * or methods from the CUDA runtime API.
+ *
+ * This macro should not be used in Thrust, as it depends on `__CUDA_ARCH__`
+ * and is not compatible with `NV_IF_TARGET`. It is provided for legacy
+ * purposes only.
+ *
+ * Replace any usages with `THRUST_RDC_ENABLED` and `NV_IF_TARGET`.
+ */
+#ifdef CUB_RUNTIME_ENABLED
+#define __THRUST_HAS_CUDART__ 1
+#else
+#define __THRUST_HAS_CUDART__ 0
+#endif
+
+// 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
+#ifdef __CUDA_ARCH__
+#define THRUST_DEVICE_CODE
+#endif // __CUDA_ARCH__
+#endif // THRUST_PROVIDE_LEGACY_ARCH_MACROS
+
+#ifdef THRUST_AGENT_ENTRY_NOINLINE
+#define THRUST_AGENT_ENTRY_INLINE_ATTR __noinline__
+#else
+#define THRUST_AGENT_ENTRY_INLINE_ATTR __forceinline__
+#endif
+
+#define THRUST_DEVICE_FUNCTION __device__ __forceinline__
+#define THRUST_HOST_FUNCTION __host__     __forceinline__
+#define THRUST_FUNCTION __host__ __device__ __forceinline__
+#if 0
+#define THRUST_ARGS(...) __VA_ARGS__
+#define THRUST_STRIP_PARENS(X) X
+#define THRUST_AGENT_ENTRY(ARGS) THRUST_FUNCTION static void entry(THRUST_STRIP_PARENS(THRUST_ARGS ARGS))
+#else
+#define THRUST_AGENT_ENTRY(...) THRUST_AGENT_ENTRY_INLINE_ATTR __device__ static void entry(__VA_ARGS__)
+#endif
+
+#ifndef THRUST_IGNORE_CUB_VERSION_CHECK
+
+#include <thrust/version.h>
+#if THRUST_VERSION != CUB_VERSION
+#error The version of CUB in your include path is not compatible with this release of Thrust. CUB is now included in the CUDA Toolkit, so you no longer need to use your own checkout of CUB. Define THRUST_IGNORE_CUB_VERSION_CHECK to ignore this.
+#endif
+
+// Make sure the CUB namespace has been declared using the modern macros:
+CUB_NAMESPACE_BEGIN
+CUB_NAMESPACE_END
+
+#else // THRUST_IGNORE_CUB_VERSION_CHECK
+
+// Make sure the CUB namespace has been declared. Use the old macros for compat
+// with older CUB:
+CUB_NS_PREFIX
+namespace cub {}
+CUB_NS_POSTFIX
+
+// Older versions of CUB do not define this. Set it to a reasonable default if
+// not provided.
+#ifndef CUB_NS_QUALIFIER
+#define CUB_NS_QUALIFIER ::cub
+#endif
+
+#endif // THRUST_IGNORE_CUB_VERSION_CHECK
+
+// Pull the fully qualified cub:: namespace into the thrust:: namespace so we
+// don't have to use CUB_NS_QUALIFIER as long as we're in thrust::.
+THRUST_NAMESPACE_BEGIN
+namespace cub
+{
+using namespace CUB_NS_QUALIFIER;
+}
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/adjacent_difference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/adjacent_difference.h
new file mode 100644
index 0000000000000000000000000000000000000000..2846112351842c0cecbc90a7db0e55e6518b558f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/adjacent_difference.h
@@ -0,0 +1,294 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/functional.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <cub/device/device_adjacent_difference.cuh>
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__ OutputIterator
+adjacent_difference(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator                                               first,
+    InputIterator                                               last,
+    OutputIterator                                              result,
+    BinaryFunction                                              binary_op);
+
+namespace cuda_cub {
+
+namespace __adjacent_difference {
+
+  template <bool MayAlias,
+            class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream)
+  {
+    if (num_items == 0)
+    {
+      return cudaSuccess;
+    }
+
+    constexpr bool may_alias = MayAlias;
+    constexpr bool read_left = true;
+
+    using Dispatch32 = cub::DispatchAdjacentDifference<InputIt,
+                                                       OutputIt,
+                                                       BinaryOp,
+                                                       thrust::detail::int32_t,
+                                                       may_alias,
+                                                       read_left>;
+    using Dispatch64 = cub::DispatchAdjacentDifference<InputIt,
+                                                       OutputIt,
+                                                       BinaryOp,
+                                                       thrust::detail::int64_t,
+                                                       may_alias,
+                                                       read_left>;
+
+    cudaError_t status;
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (d_temp_storage,
+                                 temp_storage_bytes,
+                                 first,
+                                 result,
+                                 num_items_fixed,
+                                 binary_op,
+                                 stream));
+    return status;
+  }
+
+  template <class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, false> /* comparable */)
+  {
+    constexpr bool may_alias = true;
+    return doit_step<may_alias>(d_temp_storage,
+                                temp_storage_bytes,
+                                first,
+                                result,
+                                binary_op,
+                                num_items,
+                                stream);
+  }
+
+  template <class InputIt,
+            class OutputIt,
+            class BinaryOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            InputIt first,
+            OutputIt result,
+            BinaryOp binary_op,
+            std::size_t num_items,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, true> /* comparable */)
+  {
+    // The documentation states that pointers might be equal but can't alias in
+    // any other way. That is, the distance should be equal to zero or exceed
+    // `num_items`. In the latter case, we use an optimized version.
+    if (first != result)
+    {
+      constexpr bool may_alias = false;
+      return doit_step<may_alias>(d_temp_storage,
+                                  temp_storage_bytes,
+                                  first,
+                                  result,
+                                  binary_op,
+                                  num_items,
+                                  stream);
+    }
+
+    constexpr bool may_alias = true;
+    return doit_step<may_alias>(d_temp_storage,
+                                temp_storage_bytes,
+                                first,
+                                result,
+                                binary_op,
+                                num_items,
+                                stream);
+  }
+
+  template <typename Derived,
+            typename InputIt,
+            typename OutputIt,
+            typename BinaryOp>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  adjacent_difference(execution_policy<Derived>& policy,
+                      InputIt                    first,
+                      InputIt                    last,
+                      OutputIt                   result,
+                      BinaryOp                   binary_op)
+  {
+    const auto num_items =
+      static_cast<std::size_t>(thrust::distance(first, last));
+    std::size_t storage_size = 0;
+    cudaStream_t stream = cuda_cub::stream(policy);
+
+    using UnwrapInputIt = thrust::detail::try_unwrap_contiguous_iterator_return_t<InputIt>;
+    using UnwrapOutputIt = thrust::detail::try_unwrap_contiguous_iterator_return_t<OutputIt>;
+
+    using InputValueT = thrust::iterator_value_t<UnwrapInputIt>;
+    using OutputValueT = thrust::iterator_value_t<UnwrapOutputIt>;
+
+    constexpr bool can_compare_iterators =
+      std::is_pointer<UnwrapInputIt>::value &&
+      std::is_pointer<UnwrapOutputIt>::value &&
+      std::is_same<InputValueT, OutputValueT>::value;
+
+    auto first_unwrap = thrust::detail::try_unwrap_contiguous_iterator(first);
+    auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+    thrust::detail::integral_constant<bool, can_compare_iterators> comparable;
+
+    cudaError_t status = doit_step(nullptr,
+                                   storage_size,
+                                   first_unwrap,
+                                   result_unwrap,
+                                   binary_op,
+                                   num_items,
+                                   stream,
+                                   comparable);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+
+    status = doit_step(static_cast<void *>(tmp.data().get()),
+                       storage_size,
+                       first_unwrap,
+                       result_unwrap,
+                       binary_op,
+                       num_items,
+                       stream,
+                       comparable);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed on 2nd step");
+
+    status = cuda_cub::synchronize_optional(policy);
+    cuda_cub::throw_on_error(status, "adjacent_difference failed to synchronize");
+
+    return result + num_items;
+  }
+
+}    // namespace __adjacent_difference
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class BinaryOp>
+OutputIt __host__ __device__
+adjacent_difference(execution_policy<Derived> &policy,
+                    InputIt                    first,
+                    InputIt                    last,
+                    OutputIt                   result,
+                    BinaryOp                   binary_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __adjacent_difference::adjacent_difference(policy,
+                                                         first,
+                                                         last,
+                                                         result,
+                                                         binary_op);),
+    (result = thrust::adjacent_difference(cvt_to_seq(derived_cast(policy)),
+                                          first,
+                                          last,
+                                          result,
+                                          binary_op);));
+  return result;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+adjacent_difference(execution_policy<Derived> &policy,
+                    InputIt                    first,
+                    InputIt                    last,
+                    OutputIt                   result)
+{
+  typedef typename iterator_traits<InputIt>::value_type input_type;
+  return cuda_cub::adjacent_difference(policy,
+                                       first,
+                                       last,
+                                       result,
+                                       minus<input_type>());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+//
+#include <thrust/memory.h>
+#include <thrust/adjacent_difference.h>
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/assign_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/assign_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..8945f1cac376d328ea1de38cb43608882f85b3ec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/assign_value.h
@@ -0,0 +1,94 @@
+/*
+ *  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 THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/detail/copy.h>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+template<typename DerivedPolicy, typename Pointer1, typename Pointer2>
+inline __host__ __device__
+  void assign_value(thrust::cuda::execution_policy<DerivedPolicy> &exec, Pointer1 dst, Pointer2 src)
+{
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static void host_path(thrust::cuda::execution_policy<DerivedPolicy> &exec, Pointer1 dst, Pointer2 src)
+    {
+      cuda_cub::copy(exec, src, src + 1, dst);
+    }
+
+    __device__ inline static void device_path(thrust::cuda::execution_policy<DerivedPolicy> &, Pointer1 dst, Pointer2 src)
+    {
+      *thrust::raw_pointer_cast(dst) = *thrust::raw_pointer_cast(src);
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST, (
+    war_nvbugs_881631::host_path(exec,dst,src);
+  ), (
+    war_nvbugs_881631::device_path(exec,dst,src);
+  ));
+
+} // end assign_value()
+
+
+template<typename System1, typename System2, typename Pointer1, typename Pointer2>
+inline __host__ __device__
+  void assign_value(cross_system<System1,System2> &systems, Pointer1 dst, Pointer2 src)
+{
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static void host_path(cross_system<System1,System2> &systems, Pointer1 dst, Pointer2 src)
+    {
+      // rotate the systems so that they are ordered the same as (src, dst)
+      // for the call to thrust::copy
+      cross_system<System2,System1> rotated_systems = systems.rotate();
+      cuda_cub::copy(rotated_systems, src, src + 1, dst);
+    }
+
+    __device__ inline static void device_path(cross_system<System1,System2> &, Pointer1 dst, Pointer2 src)
+    {
+      // XXX forward the true cuda::execution_policy inside systems here
+      //     instead of materializing a tag
+      thrust::cuda::tag cuda_tag;
+      thrust::cuda_cub::assign_value(cuda_tag, dst, src);
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST, (
+    war_nvbugs_881631::host_path(systems,dst,src);
+  ), (
+    war_nvbugs_881631::device_path(systems,dst,src);
+  ));
+} // end assign_value()
+
+
+} // end cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f29707594f8e90eafcb7b1496638700d638b8bc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/copy.h
@@ -0,0 +1,537 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/async/transform.h>
+#include <thrust/system/cuda/detail/cross_system.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/uninitialized_copy.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+// ContiguousIterator input and output iterators
+// TriviallyCopyable elements
+// Host to device, device to host, device to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    is_indirectly_trivially_relocatable_to<ForwardIt, OutputIt>::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(
+    select_device_system(from_exec, to_exec)
+  );
+
+  using pointer
+    = typename thrust::detail::allocator_traits<decltype(device_alloc)>::
+      template rebind_traits<void>::pointer;
+
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(
+    select_device_system(from_exec, to_exec)
+  );
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(from_exec))
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(to_exec))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        extract_dependencies(
+          std::move(thrust::detail::derived_cast(from_exec))
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(to_exec))
+        )
+      )
+    );
+  }
+
+  // Run copy.
+
+  thrust::cuda_cub::throw_on_error(
+    cudaMemcpyAsync(
+      thrust::raw_pointer_cast(&*output)
+    , thrust::raw_pointer_cast(&*first)
+    , sizeof(T) * n
+    , direction_of_copy(from_exec, to_exec)
+    , e.stream().native_handle()
+    )
+  , "after copy launch"
+  );
+
+  return e;
+}
+
+// Non-ContiguousIterator input or output, or non-TriviallyRelocatable value type
+// Device to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&   to_exec
+, ForwardIt                                   first
+, Size                                        n
+, OutputIt                                    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<
+        is_indirectly_trivially_relocatable_to<ForwardIt, OutputIt>
+      >
+    , decltype(is_device_to_device_copy(from_exec, to_exec))
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  return async_transform_n(
+    select_device_system(from_exec, to_exec)
+  , first, n, output, thrust::identity<T>()
+  );
+}
+
+template <typename OutputIt>
+void async_copy_n_compile_failure_no_cuda_to_non_contiguous_output()
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (negation<is_contiguous_iterator<OutputIt>>::value)
+  , "copying to non-ContiguousIterators in another system from the CUDA system "
+    "is not supported; use `THRUST_PROCLAIM_CONTIGUOUS_ITERATOR(Iterator)` to "
+    "indicate that an iterator points to elements that are contiguous in memory."
+  );
+}
+
+// Non-ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Device to host, host to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<is_contiguous_iterator<OutputIt>>
+    , is_trivially_relocatable_to<
+        typename iterator_traits<ForwardIt>::value_type
+      , typename iterator_traits<OutputIt>::value_type
+      >
+    , disjunction<
+        decltype(is_host_to_device_copy(from_exec, to_exec))
+      , decltype(is_device_to_host_copy(from_exec, to_exec))
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  async_copy_n_compile_failure_no_cuda_to_non_contiguous_output<OutputIt>();
+
+  return {};
+}
+
+// Workaround for MSVC's lack of expression SFINAE and also for an NVCC bug.
+// In NVCC, when two SFINAE-enabled overloads are only distinguishable by a
+// part of a SFINAE condition that is in a `decltype`, NVCC thinks they are the
+// same overload and emits an error.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt
+  // MSVC2015 WAR: doesn't like decltype(...)::value in superclass definition
+, typename IsH2DCopy = decltype(is_host_to_device_copy(
+    std::declval<FromPolicy const&>()
+  , std::declval<ToPolicy const&>()))
+>
+struct is_buffered_trivially_relocatable_host_to_device_copy
+  : thrust::integral_constant<
+      bool
+    ,    !is_contiguous_iterator<ForwardIt>::value
+      && is_contiguous_iterator<OutputIt>::value
+      && is_trivially_relocatable_to<
+            typename iterator_traits<ForwardIt>::value_type
+          , typename iterator_traits<OutputIt>::value_type
+          >::value
+      && IsH2DCopy::value
+    >
+{};
+
+// Non-ContiguousIterator input iterator, ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Host to device
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy&                               from_exec
+, thrust::cuda::execution_policy<ToPolicy>& to_exec
+, ForwardIt                                 first
+, Size                                      n
+, OutputIt                                  output
+) ->
+  typename std::enable_if<
+    is_buffered_trivially_relocatable_host_to_device_copy<
+      FromPolicy
+    , thrust::cuda::execution_policy<ToPolicy>
+    , ForwardIt, OutputIt
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const host_alloc = get_async_host_allocator(
+    from_exec
+  );
+
+  // Create host-side buffer.
+
+  auto buffer = uninitialized_allocate_unique_n<T>(host_alloc, n);
+
+  auto const buffer_ptr = buffer.get();
+
+  // Copy into host-side buffer.
+
+  // TODO: Switch to an async call once we have async interfaces for host
+  // systems and support for cross system dependencies.
+  uninitialized_copy_n(from_exec, first, n, buffer_ptr);
+
+  // Run device-side copy.
+
+  auto new_to_exec = thrust::detail::derived_cast(to_exec).rebind_after(
+    std::tuple_cat(
+      std::make_tuple(
+        std::move(buffer)
+      )
+    , extract_dependencies(
+        std::move(thrust::detail::derived_cast(from_exec))
+      )
+    , extract_dependencies(
+        std::move(thrust::detail::derived_cast(to_exec))
+      )
+    )
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(to_exec)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_to_exec)
+    )>::value
+  ));
+
+  return async_copy_n(
+    from_exec
+    // TODO: We have to cast back to the right execution_policy class. Ideally,
+    // we should be moving here.
+  , new_to_exec
+  , buffer_ptr
+  , n
+  , output
+  );
+}
+
+// Workaround for MSVC's lack of expression SFINAE and also for an NVCC bug.
+// In NVCC, when two SFINAE-enabled overloads are only distinguishable by a
+// part of a SFINAE condition that is in a `decltype`, NVCC thinks they are the
+// same overload and emits an error.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt
+  // MSVC2015 WAR: doesn't like decltype(...)::value in superclass definition
+, typename IsD2HCopy = decltype(is_device_to_host_copy(
+    std::declval<FromPolicy const&>()
+  , std::declval<ToPolicy const&>()))
+>
+struct is_buffered_trivially_relocatable_device_to_host_copy
+  : thrust::integral_constant<
+      bool
+    ,    !is_contiguous_iterator<ForwardIt>::value
+      && is_contiguous_iterator<OutputIt>::value
+      && is_trivially_relocatable_to<
+            typename iterator_traits<ForwardIt>::value_type
+          , typename iterator_traits<OutputIt>::value_type
+          >::value
+      && IsD2HCopy::value
+    >
+{};
+
+// Non-ContiguousIterator input iterator, ContiguousIterator output iterator
+// TriviallyRelocatable value type
+// Device to host
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, ToPolicy&                                   to_exec
+, ForwardIt                                   first
+, Size                                        n
+, OutputIt                                    output
+) ->
+  typename std::enable_if<
+    is_buffered_trivially_relocatable_device_to_host_copy<
+      thrust::cuda::execution_policy<FromPolicy>
+    , ToPolicy
+    , ForwardIt, OutputIt
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(
+    from_exec
+  );
+
+  // Create device-side buffer.
+
+  auto buffer = uninitialized_allocate_unique_n<T>(device_alloc, n);
+
+  auto const buffer_ptr = buffer.get();
+
+  // Run device-side copy.
+
+  auto f0 = async_copy_n(
+    from_exec
+  , from_exec
+  , first
+  , n
+  , buffer_ptr
+  );
+
+  // Run copy back to host.
+
+  auto new_from_exec = thrust::detail::derived_cast(from_exec).rebind_after(
+    std::move(buffer)
+  , std::move(f0)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(from_exec)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_from_exec)
+    )>::value
+  ));
+
+  return async_copy_n(
+    new_from_exec
+  , to_exec
+  , buffer_ptr
+  , n
+  , output
+  );
+}
+
+template <typename InputType, typename OutputType>
+void async_copy_n_compile_failure_non_trivially_relocatable_elements()
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (is_trivially_relocatable_to<OutputType, InputType>::value)
+  , "only sequences of TriviallyRelocatable elements can be copied to and from "
+    "the CUDA system; use `THRUST_PROCLAIM_TRIVIALLY_RELOCATABLE(T)` to "
+    "indicate that a type can be copied by bitwise (e.g. by `memcpy`)"
+  );
+}
+
+// Non-TriviallyRelocatable value type
+// Host to device, device to host
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename OutputIt, typename Size
+>
+auto async_copy_n(
+  FromPolicy& from_exec
+, ToPolicy&   to_exec
+, ForwardIt   first
+, Size        n
+, OutputIt    output
+) ->
+  typename std::enable_if<
+    conjunction<
+      negation<
+        is_trivially_relocatable_to<
+          typename iterator_traits<ForwardIt>::value_type
+        , typename iterator_traits<OutputIt>::value_type
+        >
+      >
+    , disjunction<
+        decltype(is_host_to_device_copy(from_exec, to_exec))
+      , decltype(is_device_to_host_copy(from_exec, to_exec))
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  // TODO: We could do more here with cudaHostRegister.
+
+  async_copy_n_compile_failure_non_trivially_relocatable_elements<
+    typename thrust::iterator_traits<ForwardIt>::value_type
+  , typename std::add_lvalue_reference<
+      typename thrust::iterator_traits<OutputIt>::value_type
+    >::type
+  >();
+
+  return {};
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cuda::execution_policy<FromPolicy>&         from_exec
+, thrust::cpp::execution_policy<ToPolicy>&            to_exec
+, ForwardIt                                           first
+, Sentinel                                            last
+, OutputIt                                            output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cpp::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&  to_exec
+, ForwardIt                                  first
+, Sentinel                                   last
+, OutputIt                                   output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+// ADL entry point.
+template <
+  typename FromPolicy, typename ToPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+>
+auto async_copy(
+  thrust::cuda::execution_policy<FromPolicy>& from_exec
+, thrust::cuda::execution_policy<ToPolicy>&   to_exec
+, ForwardIt                                   first
+, Sentinel                                    last
+, OutputIt                                    output
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_copy_n(
+    from_exec, to_exec, first, distance(first, last), output
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/customization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/customization.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f125a6f41899715627bea7c1fa97e8e09319ff1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/customization.h
@@ -0,0 +1,127 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/execute_with_allocator.h>
+#include <thrust/system/cuda/memory_resource.h>
+#include <thrust/mr/host_memory_resource.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/disjoint_sync_pool.h>
+#include <thrust/mr/sync_pool.h>
+#include <thrust/per_device_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+using default_async_host_resource =
+  thrust::mr::synchronized_pool_resource<
+    thrust::host_memory_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_host_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::mr::stateless_resource_allocator<
+    thrust::detail::uint8_t, default_async_host_resource
+  >{}
+)
+
+///////////////////////////////////////////////////////////////////////////////
+
+using default_async_device_resource =
+  thrust::mr::disjoint_synchronized_pool_resource<
+    thrust::system::cuda::memory_resource
+  , thrust::mr::new_delete_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_device_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::per_device_allocator<
+    thrust::detail::uint8_t, default_async_device_resource, par_t
+  >{}
+)
+
+template <typename Allocator, template <typename> class BaseSystem>
+auto get_async_device_allocator(
+  thrust::detail::execute_with_allocator<Allocator, BaseSystem>& exec
+)
+THRUST_RETURNS(exec.get_allocator())
+
+template <typename Allocator, template <typename> class BaseSystem>
+auto get_async_device_allocator(
+  thrust::detail::execute_with_allocator_and_dependencies<
+    Allocator, BaseSystem
+  >& exec
+)
+THRUST_RETURNS(exec.get_allocator())
+
+///////////////////////////////////////////////////////////////////////////////
+
+using default_async_universal_host_pinned_resource =
+  thrust::mr::synchronized_pool_resource<
+    thrust::system::cuda::universal_host_pinned_memory_resource
+  >;
+
+template <typename DerivedPolicy>
+auto get_async_universal_host_pinned_allocator(
+  thrust::detail::execution_policy_base<DerivedPolicy>&
+)
+THRUST_RETURNS(
+  thrust::mr::stateless_resource_allocator<
+    thrust::detail::uint8_t, default_async_universal_host_pinned_resource
+  >{}
+)
+
+}}} // namespace system::cuda::detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/exclusive_scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/exclusive_scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b120a434a3f92fa8ed6268542683a47a19cad35
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/exclusive_scan.h
@@ -0,0 +1,201 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/future.h>
+
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+// TODO specialize for thrust::plus to use e.g. ExclusiveSum instead of ExcScan
+//  - Note that thrust::plus<> is transparent, cub::Sum is not. This should be
+//    fixed in CUB first).
+//  - Need to check if CUB actually optimizes for sums before putting in effort
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Size,
+          typename OutputIt,
+          typename InitialValueType,
+          typename BinaryOp>
+unique_eager_event
+async_exclusive_scan_n(execution_policy<DerivedPolicy>& policy,
+                       ForwardIt first,
+                       Size n,
+                       OutputIt out,
+                       InitialValueType init,
+                       BinaryOp op)
+{
+  using InputValueT = cub::detail::InputValue<InitialValueType>;
+  using Dispatch32 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       InputValueT,
+                                       thrust::detail::int32_t,
+                                       InitialValueType>;
+  using Dispatch64 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       InputValueT,
+                                       thrust::detail::int64_t,
+                                       InitialValueType>;
+
+  InputValueT init_value(init);
+
+  auto const device_alloc = get_async_device_allocator(policy);
+  unique_eager_event ev;
+
+  // Determine temporary device storage requirements.
+  cudaError_t status;
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (nullptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  init_value,
+                                  n_fixed,
+                                  nullptr));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan");
+  }
+
+  // Allocate temporary storage.
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+  void* const tmp_ptr = raw_pointer_cast(content.get());
+
+  // Set up stream with dependencies.
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content),
+          unique_stream(nonowning, user_raw_stream)
+        ),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+  else
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(std::move(content)),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+
+  // Run scan.
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (tmp_ptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  init_value,
+                                  n_fixed,
+                                  user_raw_stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching exclusive_scan kernel");
+  }
+
+  return ev;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename InitialValueType,
+          typename BinaryOp>
+auto async_exclusive_scan(execution_policy<DerivedPolicy>& policy,
+                          ForwardIt first,
+                          Sentinel&& last,
+                          OutputIt&& out,
+                          InitialValueType &&init,
+                          BinaryOp&& op)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_exclusive_scan_n(
+    policy,
+    first,
+    distance(first, THRUST_FWD(last)),
+    THRUST_FWD(out),
+    THRUST_FWD(init),
+    THRUST_FWD(op)
+  )
+)
+
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif // C++14
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6809fe0a4626b5b93e6d8ebdc39f59b0660ff01
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/for_each.h
@@ -0,0 +1,157 @@
+
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <typename ForwardIt, typename UnaryFunction>
+struct async_for_each_fn
+{
+  ForwardIt first;
+  UnaryFunction f;
+
+  __host__ __device__
+  async_for_each_fn(ForwardIt&& first_, UnaryFunction&& f_)
+    : first(std::move(first_)), f(std::move(f_))
+  {}
+
+  template <typename Index>
+  __host__ __device__
+  void operator()(Index idx)
+  {
+    f(thrust::raw_reference_cast(first[idx]));
+  }
+};
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename UnaryFunction
+>
+unique_eager_event async_for_each_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  UnaryFunction                    func
+) {
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      extract_dependencies(
+        std::move(thrust::detail::derived_cast(policy))
+      )
+    );
+  }
+
+  // Run for_each.
+
+  async_for_each_fn<ForwardIt, UnaryFunction> wrapped(
+    std::move(first), std::move(func)
+  );
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__parallel_for::parallel_for(
+      n, std::move(wrapped), e.stream().native_handle()
+    )
+  , "after for_each launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename UnaryFunction
+>
+auto async_for_each(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  UnaryFunction&&                  func
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_for_each_n(
+    policy, first, distance(first, last), THRUST_FWD(func)
+  )
+);
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/inclusive_scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/inclusive_scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..363347c35312e35b027063b56b888beee649a3aa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/inclusive_scan.h
@@ -0,0 +1,194 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/future.h>
+
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+// TODO specialize for thrust::plus to use e.g. InclusiveSum instead of IncScan
+//  - Note that thrust::plus<> is transparent, cub::Sum is not. This should be
+//    fixed in CUB first).
+//  - Need to check if CUB actually optimizes for sums before putting in effort
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Size,
+          typename OutputIt,
+          typename BinaryOp>
+unique_eager_event
+async_inclusive_scan_n(execution_policy<DerivedPolicy>& policy,
+                       ForwardIt first,
+                       Size n,
+                       OutputIt out,
+                       BinaryOp op)
+{
+  using AccumT = typename thrust::iterator_traits<ForwardIt>::value_type;
+  using Dispatch32 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       cub::NullType,
+                                       thrust::detail::int32_t,
+                                       AccumT>;
+  using Dispatch64 = cub::DispatchScan<ForwardIt,
+                                       OutputIt,
+                                       BinaryOp,
+                                       cub::NullType,
+                                       thrust::detail::int64_t,
+                                       AccumT>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+  unique_eager_event ev;
+
+  // Determine temporary device storage requirements.
+  cudaError_t status;
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (nullptr,
+                                  tmp_size,
+                                  first,
+                                  out,
+                                  op,
+                                  cub::NullType{},
+                                  n_fixed,
+                                  nullptr));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan");
+  }
+
+  // Allocate temporary storage.
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+  void* const tmp_ptr = raw_pointer_cast(content.get());
+
+  // Set up stream with dependencies.
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content),
+          unique_stream(nonowning, user_raw_stream)
+        ),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+  else
+  {
+    ev = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(std::move(content)),
+        extract_dependencies(std::move(thrust::detail::derived_cast(policy)))));
+  }
+
+  // Run scan.
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                n,
+                                (tmp_ptr,
+                                 tmp_size,
+                                 first,
+                                 out,
+                                 op,
+                                 cub::NullType{},
+                                 n_fixed,
+                                 user_raw_stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching inclusive_scan kernel");
+  }
+
+  return ev;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <typename DerivedPolicy,
+          typename ForwardIt,
+          typename Sentinel,
+          typename OutputIt,
+          typename BinaryOp>
+auto async_inclusive_scan(execution_policy<DerivedPolicy>& policy,
+                          ForwardIt first,
+                          Sentinel&& last,
+                          OutputIt&& out,
+                          BinaryOp&& op)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_inclusive_scan_n(
+    policy,
+    first,
+    distance(first, THRUST_FWD(last)),
+    THRUST_FWD(out),
+    THRUST_FWD(op)
+  )
+)
+
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif // C++14
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d0dbfe16f6231938e499cfb0e196cbb72bec332
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/reduce.h
@@ -0,0 +1,343 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Optimize for thrust::plus
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename T, typename BinaryOp
+>
+unique_eager_future<remove_cvref_t<T>> async_reduce_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, T                                init
+, BinaryOp                         op
+) {
+  using U = remove_cvref_t<T>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  using pointer
+    = typename thrust::detail::allocator_traits<decltype(device_alloc)>::
+      template rebind_traits<U>::pointer;
+
+  unique_eager_future_promise_pair<U, pointer> fp;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<U*>(nullptr)
+    , n
+    , op
+    , init
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after reduction sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, sizeof(U) + tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+  U* const ret_ptr = thrust::detail::aligned_reinterpret_cast<U*>(
+    raw_pointer_cast(content_ptr)
+  );
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr + sizeof(U))
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    fp = make_dependent_future<U, pointer>(
+      [] (decltype(content) const& c)
+      {
+        return pointer(
+          thrust::detail::aligned_reinterpret_cast<U*>(
+            raw_pointer_cast(c.get())
+          )
+        );
+      }
+    , std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    fp = make_dependent_future<U, pointer>(
+      [] (decltype(content) const& c)
+      {
+        return pointer(
+          thrust::detail::aligned_reinterpret_cast<U*>(
+            raw_pointer_cast(c.get())
+          )
+        );
+      }
+    , std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run reduction.
+
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      tmp_ptr
+    , tmp_size
+    , first
+    , ret_ptr
+    , n
+    , op
+    , init
+    , fp.future.stream().native_handle()
+    )
+  , "after reduction launch"
+  );
+
+  return std::move(fp.future);
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename T, typename BinaryOp
+>
+auto async_reduce(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Sentinel                         last
+, T                                init
+, BinaryOp                         op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_reduce_n(
+    policy, first, distance(first, last), init, op
+  )
+)
+
+} // cuda_cub
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename OutputIt
+, typename T, typename BinaryOp
+>
+unique_eager_event async_reduce_into_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, OutputIt                         output
+, T                                init
+, BinaryOp                         op
+) {
+  using U = remove_cvref_t<T>;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<U*>(nullptr)
+    , n
+    , op
+    , init
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after reduction sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run reduction.
+
+  thrust::cuda_cub::throw_on_error(
+    cub::DeviceReduce::Reduce(
+      tmp_ptr
+    , tmp_size
+    , first
+    , output
+    , n
+    , op
+    , init
+    , e.stream().native_handle()
+    )
+  , "after reduction launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename T, typename BinaryOp
+>
+auto async_reduce_into(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Sentinel                         last
+, OutputIt                         output
+, T                                init
+, BinaryOp                         op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_reduce_into_n(
+    policy, first, distance(first, last), output, init, op
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a9f31681ec5b336d8020be82028debe7a280ec2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/scan.h
@@ -0,0 +1,33 @@
+/******************************************************************************
+ * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/cpp14_required.h>
+
+#include <thrust/system/cuda/detail/async/exclusive_scan.h>
+#include <thrust/system/cuda/detail/async/inclusive_scan.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..f501f19c580e05a342d891f26b36bf098a95adb8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/sort.h
@@ -0,0 +1,517 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/async/copy.h>
+#include <thrust/system/cuda/detail/sort.h>
+#include <thrust/detail/alignment.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+#include <thrust/type_traits/is_operator_less_or_greater_function_object.h>
+#include <thrust/type_traits/logical_metafunctions.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/distance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+// Non-ContiguousIterator input and output iterators
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    negation<is_contiguous_iterator<ForwardIt>>::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  // Create device-side buffer.
+
+  // FIXME: Combine this temporary allocation with the main one for CUB.
+  auto device_buffer = uninitialized_allocate_unique_n<T>(device_alloc, n);
+
+  auto const device_buffer_ptr = device_buffer.get();
+
+  // Synthesize a suitable new execution policy, because we don't want to
+  // try and extract twice from the one we were passed.
+  typename remove_cvref_t<decltype(policy)>::tag_type tag_policy{};
+
+  // Copy from the input into the buffer.
+
+  auto new_policy0 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(device_buffer)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy0)
+    )>::value
+  ));
+
+  auto f0 = async_copy_n(
+    new_policy0
+  , tag_policy
+  , first
+  , n
+  , device_buffer_ptr
+  );
+
+  // Sort the buffer.
+
+  auto new_policy1 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(f0)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy1)
+    )>::value
+  ));
+
+  auto f1 = async_sort_n(
+    new_policy1
+  , tag_policy
+  , device_buffer_ptr
+  , n
+  , comp
+  );
+
+  // Copy from the buffer into the input.
+  // FIXME: Combine this with the potential memcpy at the end of the main sort
+  // routine.
+
+  auto new_policy2 = thrust::detail::derived_cast(policy).rebind_after(
+    std::move(f1)
+  );
+
+  THRUST_STATIC_ASSERT((
+    std::tuple_size<decltype(
+      extract_dependencies(policy)
+    )>::value + 1
+    <=
+    std::tuple_size<decltype(
+      extract_dependencies(new_policy2)
+    )>::value
+  ));
+
+  return async_copy_n(
+    new_policy2
+  , tag_policy
+  , device_buffer_ptr
+  , n
+  , first
+  );
+}
+
+// ContiguousIterator iterators
+// Non-Scalar value type or user-defined StrictWeakOrdering
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    conjunction<
+      is_contiguous_iterator<ForwardIt>
+    , disjunction<
+        negation<
+          std::is_scalar<
+            typename iterator_traits<ForwardIt>::value_type
+          >
+        >
+      , negation<
+          is_operator_less_or_greater_function_object<StrictWeakOrdering>
+        >
+      >
+    >::value
+  , unique_eager_event
+  >::type
+{
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__merge_sort::doit_step<
+      /* Sort items? */ std::false_type, /* Stable? */ std::true_type
+    >(
+      nullptr
+    , tmp_size
+    , first
+    , static_cast<thrust::detail::uint8_t*>(nullptr) // Items.
+    , n
+    , comp
+    , nullptr // Null stream, just for sizing.
+    )
+  , "after merge sort sizing"
+  );
+
+  // Allocate temporary storage.
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run merge sort.
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__merge_sort::doit_step<
+      /* Sort items? */ std::false_type, /* Stable? */ std::true_type
+    >(
+      tmp_ptr
+    , tmp_size
+    , first
+    , static_cast<thrust::detail::uint8_t*>(nullptr) // Items.
+    , n
+    , comp
+    , e.stream().native_handle()
+    )
+  , "after merge sort sizing"
+  );
+
+  return e;
+}
+
+template <typename T, typename Size, typename StrictWeakOrdering>
+typename std::enable_if<
+  is_operator_less_function_object<StrictWeakOrdering>::value
+, cudaError_t
+>::type
+invoke_radix_sort(
+  cudaStream_t          stream
+, void*                 tmp_ptr
+, std::size_t&          tmp_size
+, cub::DoubleBuffer<T>& keys
+, Size&                 n
+, StrictWeakOrdering
+)
+{
+  return cub::DeviceRadixSort::SortKeys(
+    tmp_ptr
+  , tmp_size
+  , keys
+  , n
+  , 0
+  , sizeof(T) * 8
+  , stream
+  );
+}
+
+template <typename T, typename Size, typename StrictWeakOrdering>
+typename std::enable_if<
+  is_operator_greater_function_object<StrictWeakOrdering>::value
+, cudaError_t
+>::type
+invoke_radix_sort(
+  cudaStream_t          stream
+, void*                 tmp_ptr
+, std::size_t&          tmp_size
+, cub::DoubleBuffer<T>& keys
+, Size&                 n
+, StrictWeakOrdering
+)
+{
+  return cub::DeviceRadixSort::SortKeysDescending(
+    tmp_ptr
+  , tmp_size
+  , keys
+  , n
+  , 0
+  , sizeof(T) * 8
+  , stream
+  );
+}
+
+// ContiguousIterator iterators
+// Scalar value type
+// operator< or operator>
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename StrictWeakOrdering
+>
+auto async_stable_sort_n(
+  execution_policy<DerivedPolicy>& policy
+, ForwardIt                        first
+, Size                             n
+, StrictWeakOrdering               comp
+) ->
+  typename std::enable_if<
+    conjunction<
+      is_contiguous_iterator<ForwardIt>
+    , std::is_scalar<
+        typename iterator_traits<ForwardIt>::value_type
+      >
+    , is_operator_less_or_greater_function_object<StrictWeakOrdering>
+    >::value
+  , unique_eager_event
+  >::type
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  auto const device_alloc = get_async_device_allocator(policy);
+
+  unique_eager_event e;
+
+  cub::DoubleBuffer<T> keys(
+    raw_pointer_cast(&*first), nullptr
+  );
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+  thrust::cuda_cub::throw_on_error(
+    invoke_radix_sort(
+      nullptr // Null stream, just for sizing.
+    , nullptr
+    , tmp_size
+    , keys
+    , n
+    , comp
+    )
+  , "after radix sort sizing"
+  );
+
+  // Allocate temporary storage.
+
+  size_t keys_temp_storage = thrust::detail::aligned_storage_size(
+    sizeof(T) * n, 128
+  );
+
+  auto content = uninitialized_allocate_unique_n<thrust::detail::uint8_t>(
+    device_alloc, keys_temp_storage + tmp_size
+  );
+
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  auto const content_ptr = content.get();
+
+  keys.d_buffers[1] = thrust::detail::aligned_reinterpret_cast<T*>(
+    raw_pointer_cast(content_ptr)
+  );
+
+  void* const tmp_ptr = static_cast<void*>(
+    raw_pointer_cast(content_ptr + keys_temp_storage)
+  );
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        , unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          std::move(content)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+
+  // Run radix sort.
+
+  thrust::cuda_cub::throw_on_error(
+    invoke_radix_sort(
+      e.stream().native_handle()
+    , tmp_ptr
+    , tmp_size
+    , keys
+    , n
+    , comp
+    )
+  , "after radix sort launch"
+  );
+
+  if (0 != keys.selector)
+  {
+    auto new_policy0 = thrust::detail::derived_cast(policy).rebind_after(
+      std::move(e)
+    );
+
+    THRUST_STATIC_ASSERT((
+      std::tuple_size<decltype(
+        extract_dependencies(policy)
+      )>::value + 1
+      <=
+      std::tuple_size<decltype(
+        extract_dependencies(new_policy0)
+      )>::value
+    ));
+
+    // Synthesize a suitable new execution policy, because we don't want to
+    // try and extract twice from the one we were passed.
+    typename remove_cvref_t<decltype(policy)>::tag_type tag_policy{};
+
+    using return_future = decltype(e);
+    return return_future(async_copy_n(
+      new_policy0
+    , tag_policy
+    , keys.d_buffers[1]
+    , n
+    , keys.d_buffers[0]
+    ));
+  }
+  else
+    return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename StrictWeakOrdering
+>
+auto async_stable_sort(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  StrictWeakOrdering               comp
+)
+// A GCC 5 bug requires an explicit trailing return type here, so stick with
+// THRUST_DECLTYPE_RETURNS for now.
+THRUST_DECLTYPE_RETURNS(
+  thrust::system::cuda::detail::async_stable_sort_n(
+    policy, first, distance(first, last), comp
+  )
+)
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..a971300f229196f29394cc9ab30646f80ab95ab2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/async/transform.h
@@ -0,0 +1,161 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+// TODO: Move into system::cuda
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/async/customization.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda { namespace detail
+{
+
+template <typename ForwardIt, typename OutputIt, typename UnaryOperation>
+struct async_transform_fn
+{
+  ForwardIt first_;
+  OutputIt output_;
+  UnaryOperation op_;
+
+  __host__ __device__
+  async_transform_fn(ForwardIt&& first, OutputIt&& output, UnaryOperation&& op)
+    : first_(std::move(first)), output_(std::move(output)), op_(std::move(op))
+  {}
+
+  template <typename Index>
+  __host__ __device__
+  void operator()(Index idx)
+  {
+    output_[idx] = op_(thrust::raw_reference_cast(first_[idx]));
+  }
+};
+
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Size, typename OutputIt, typename UnaryOperation
+>
+unique_eager_event async_transform_n(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Size                             n,
+  OutputIt                         output,
+  UnaryOperation                   op
+) {
+  unique_eager_event e;
+
+  // Set up stream with dependencies.
+
+  cudaStream_t const user_raw_stream = thrust::cuda_cub::stream(policy);
+
+  if (thrust::cuda_cub::default_stream() != user_raw_stream)
+  {
+    e = make_dependent_event(
+      std::tuple_cat(
+        std::make_tuple(
+          unique_stream(nonowning, user_raw_stream)
+        )
+      , extract_dependencies(
+          std::move(thrust::detail::derived_cast(policy))
+        )
+      )
+    );
+  }
+  else
+  {
+    e = make_dependent_event(
+      extract_dependencies(
+        std::move(thrust::detail::derived_cast(policy))
+      )
+    );
+  }
+
+  // Run transform.
+
+  async_transform_fn<ForwardIt, OutputIt, UnaryOperation> wrapped(
+    std::move(first), std::move(output), std::move(op)
+  );
+
+  thrust::cuda_cub::throw_on_error(
+    thrust::cuda_cub::__parallel_for::parallel_for(
+      n, std::move(wrapped), e.stream().native_handle()
+    )
+  , "after transform launch"
+  );
+
+  return e;
+}
+
+}}} // namespace system::cuda::detail
+
+namespace cuda_cub
+{
+
+// ADL entry point.
+template <
+  typename DerivedPolicy
+, typename ForwardIt, typename Sentinel, typename OutputIt
+, typename UnaryOperation
+>
+auto async_transform(
+  execution_policy<DerivedPolicy>& policy,
+  ForwardIt                        first,
+  Sentinel                         last,
+  OutputIt                         output,
+  UnaryOperation&&                 op
+)
+THRUST_RETURNS(
+  thrust::system::cuda::detail::async_transform_n(
+    policy, first, distance(first, last), output, THRUST_FWD(op)
+  )
+);
+
+} // cuda_cub
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/binary_search.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/binary_search.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb769a4ac0af1c967a9d921e8456c97a124d02c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/binary_search.h
@@ -0,0 +1,19 @@
+/*
+*  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
+
+// this system has no special version of this algorithm
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cdp_dispatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cdp_dispatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..f94e5dd9265b6edcab33f002964145f0d7a8541e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cdp_dispatch.h
@@ -0,0 +1,88 @@
+/*
+*  Copyright 2021-2022 NVIDIA Corporation
+*
+*  Licensed under the Apache License, Version 2.0 (the "License");
+*  you may not use this file except in compliance with the License.
+*  You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+*  Unless required by applicable law or agreed to in writing, software
+*  distributed under the License is distributed on an "AS IS" BASIS,
+*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*  See the License for the specific language governing permissions and
+*  limitations under the License.
+*/
+
+/**
+ * \file
+ * Utilities for CUDA dynamic parallelism.
+ */
+
+#pragma once
+
+#include <cub/config.cuh>
+#include <cub/detail/detect_cuda_runtime.cuh>
+
+#include <nv/target>
+
+/**
+ * \def THRUST_CDP_DISPATCH
+ *
+ * If CUDA Dynamic Parallelism / CUDA Nested Parallelism is available, always
+ * run the parallel implementation. Otherwise, run the parallel implementation
+ * when called from the host, and fallback to the sequential implementation on
+ * the device.
+ *
+ * `par_impl` and `seq_impl` are blocks of C++ statements enclosed in
+ * parentheses, similar to NV_IF_TARGET blocks:
+ *
+ * \code
+ * THRUST_CDP_DISPATCH((launch_parallel_kernel();), (run_serial_impl();));
+ * \endcode
+ */
+
+#if defined(CUB_DETAIL_CDPv1)
+
+// Special case for NVCC -- need to inform the device path about the kernels
+// that are launched from the host path.
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
+
+// seq_impl only used on platforms that do not support device synchronization.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  if (false)                                                                   \
+  { /* Without this, the device pass won't compile any kernels. */             \
+    NV_IF_TARGET(NV_ANY_TARGET, par_impl);                                     \
+  }                                                                            \
+  NV_IF_TARGET(NV_PROVIDES_SM_90, seq_impl, par_impl)
+
+#else // NVCC device pass
+
+// seq_impl only used on platforms that do not support device synchronization.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  NV_IF_TARGET(NV_PROVIDES_SM_90, seq_impl, par_impl)
+
+#endif // NVCC device pass
+
+#else // CDPv1 unavailable. Always fallback to serial on device:
+
+// Special case for NVCC -- need to inform the device path about the kernels
+// that are launched from the host path.
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
+
+// Device-side launch not supported, fallback to sequential in device code.
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  if (false)                                                                   \
+  { /* Without this, the device pass won't compile any kernels. */             \
+    NV_IF_TARGET(NV_ANY_TARGET, par_impl);                                     \
+  }                                                                            \
+  NV_IF_TARGET(NV_IS_HOST, par_impl, seq_impl)
+
+#else // !(NVCC device pass):
+
+#define THRUST_CDP_DISPATCH(par_impl, seq_impl)                                \
+  NV_IF_TARGET(NV_IS_HOST, par_impl, seq_impl)
+
+#endif // NVCC device pass
+
+#endif // CDP version
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..02a5d2ac1a6a8aa11c1ef011401cea57ab6f2ae1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy.h
@@ -0,0 +1,184 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/advance.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/cross_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy, typename InputIt, typename OutputIt>
+__host__ __device__ OutputIt
+copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+     InputIt                                                     first,
+     InputIt                                                     last,
+     OutputIt                                                    result);
+
+template <class DerivedPolicy, class InputIt, class Size, class OutputIt>
+__host__ __device__ OutputIt
+copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+       InputIt                                                     first,
+       Size                                                        n,
+       OutputIt                                                    result);
+
+namespace cuda_cub {
+
+// D->D copy requires NVCC compiler
+template <class System,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy(execution_policy<System> &system,
+     InputIterator             first,
+     InputIterator             last,
+     OutputIterator            result);
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__
+copy(cross_system<System1, System2> systems,
+     InputIterator  first,
+     InputIterator  last,
+     OutputIterator result);
+
+template <class System,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy_n(execution_policy<System> &system,
+       InputIterator             first,
+       Size                      n,
+       OutputIterator            result);
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__
+copy_n(cross_system<System1, System2> systems,
+       InputIterator  first,
+       Size           n,
+       OutputIterator result);
+
+}    // namespace cuda_
+THRUST_NAMESPACE_END
+
+
+
+#include <thrust/system/cuda/detail/internal/copy_device_to_device.h>
+#include <thrust/system/cuda/detail/internal/copy_cross_system.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+// D->D copy requires NVCC compiler
+
+__thrust_exec_check_disable__
+template <class System,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy(execution_policy<System> &system,
+     InputIterator             first,
+     InputIterator             last,
+     OutputIterator            result)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __copy::device_to_device(system, first, last, result);),
+    (result =
+       thrust::copy(cvt_to_seq(derived_cast(system)), first, last, result);));
+  return result;
+}    // end copy()
+
+__thrust_exec_check_disable__
+template <class System,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__ __device__
+copy_n(execution_policy<System> &system,
+       InputIterator             first,
+       Size                      n,
+       OutputIterator            result)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __copy::device_to_device(system,
+                                       first,
+                                       thrust::next(first, n),
+                                       result);),
+    (result =
+       thrust::copy_n(cvt_to_seq(derived_cast(system)), first, n, result);));
+  return result;
+} // end copy_n()
+#endif
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class OutputIterator>
+OutputIterator __host__
+copy(cross_system<System1, System2> systems,
+     InputIterator  first,
+     InputIterator  last,
+     OutputIterator result)
+{
+  return __copy::cross_system_copy(systems,first,last,result);
+} // end copy()
+
+template <class System1,
+          class System2,
+          class InputIterator,
+          class Size,
+          class OutputIterator>
+OutputIterator __host__
+copy_n(cross_system<System1, System2> systems,
+       InputIterator  first,
+       Size           n,
+       OutputIterator result)
+{
+  return __copy::cross_system_copy_n(systems, first, n, result);
+} // end copy_n()
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/detail/temporary_array.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy_if.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy_if.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e760c086fba56f7896f0d470fa3bb3f1b98ba61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/copy_if.h
@@ -0,0 +1,831 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/function.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+// XXX declare generic copy_if interface
+// to avoid circulular dependency from thrust/copy.h
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+__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>
+__host__ __device__
+    OutputIterator
+    copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            InputIterator1                                              first,
+            InputIterator1                                              last,
+            InputIterator2                                              stencil,
+            OutputIterator                                              result,
+            Predicate                                                   pred);
+
+namespace cuda_cub {
+
+namespace __copy_if {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS      = _BLOCK_THREADS,
+      ITEMS_PER_THREAD   = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE     = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class, class>
+  struct Tuning;
+
+  template<class T>
+  struct Tuning<sm52, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<350>
+
+
+  template<class T>
+  struct Tuning<sm35, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 10,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<350>
+
+  template<class T>
+  struct Tuning<sm30, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(3, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<300>
+
+  struct no_stencil_tag_    {};
+  typedef no_stencil_tag_* no_stencil_tag;
+  template <class ItemsIt,
+            class StencilIt,
+            class OutputIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutputIt>
+  struct CopyIfAgent
+  {
+    typedef typename iterator_traits<ItemsIt>::value_type   item_type;
+    typedef typename iterator_traits<StencilIt>::value_type stencil_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, item_type>::type
+    {
+      typedef Tuning<Arch,item_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt>::type   ItemsLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, StencilIt>::type StencilLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt>::type   BlockLoadItems;
+      typedef typename core::BlockLoad<PtxPlan, StencilLoadIt>::type BlockLoadStencil;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage          scan;
+          typename TilePrefixCallback::TempStorage prefix;
+        } scan_storage;
+
+        typename BlockLoadItems::TempStorage   load_items;
+        typename BlockLoadStencil::TempStorage load_stencil;
+
+        core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE> raw_exchange;
+      };    // union TempStorage
+    };    // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::ItemsLoadIt        ItemsLoadIt;
+    typedef typename ptx_plan::StencilLoadIt      StencilLoadIt;
+    typedef typename ptx_plan::BlockLoadItems     BlockLoadItems;
+    typedef typename ptx_plan::BlockLoadStencil   BlockLoadStencil;
+    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan          BlockScan;
+    typedef typename ptx_plan::TempStorage        TempStorage;
+
+    enum
+    {
+      USE_STENCIL      = !thrust::detail::is_same<StencilIt, no_stencil_tag>::value,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &  storage;
+      ScanTileState &tile_state;
+      ItemsLoadIt    items_load_it;
+      StencilLoadIt  stencil_load_it;
+      OutputIt       output_it;
+      Predicate      predicate;
+      Size           num_items;
+
+      //------------------------------------------
+      // scatter results to memory
+      //------------------------------------------
+
+      THRUST_DEVICE_FUNCTION void
+      scatter(item_type (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  num_tile_selections,
+              Size num_selections_prefix)
+      {
+        using core::sync_threadblock;
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int local_scatter_offset = selection_indices[ITEM] -
+                                     num_selections_prefix;
+          if (selection_flags[ITEM])
+          {
+            new (&storage.raw_exchange[local_scatter_offset]) item_type(items[ITEM]);
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          output_it[num_selections_prefix + item] = storage.raw_exchange[item];
+        }
+      }    // func scatter
+
+      //------------------------------------------
+      // specialize predicate on different types
+      //------------------------------------------
+
+      template <int T>
+      struct __tag {};
+
+      enum ItemStencil
+      {
+        ITEM,
+        STENCIL
+      };
+
+      template <bool TAG, class T>
+      struct wrap_value
+      {
+        T const &              x;
+        THRUST_DEVICE_FUNCTION wrap_value(T const &x) : x(x) {}
+
+        THRUST_DEVICE_FUNCTION T const &operator()() const { return x; };
+      };    // struct wrap_type
+
+      //------- item
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &x,
+                        __tag<false /* USE_STENCIL */>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+      //-------- stencil
+
+      template <class T>
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, T> const &x,
+                        __tag<true>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, no_stencil_tag_> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, stencil_type> const &,
+                        __tag<false>)
+      {
+        return false;
+      }
+
+      template <bool IS_LAST_TILE, ItemStencil TYPE, class T>
+      THRUST_DEVICE_FUNCTION void
+      compute_selection_flags(int num_tile_items,
+                              T (&values)[ITEMS_PER_THREAD],
+                              Size (&selection_flags)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Out-of-bounds items are selection_flags
+          selection_flags[ITEM] = 1;
+
+          if (!IS_LAST_TILE ||
+              (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM < num_tile_items))
+          {
+            selection_flags[ITEM] =
+                predicate_wrapper(wrap_value<TYPE, T>(values[ITEM]),
+                                  __tag<USE_STENCIL>());
+          }
+        }
+      }
+
+      //------------------------------------------
+      // consume tiles
+      //------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        item_type items_loc[ITEMS_PER_THREAD];
+        Size      selection_flags[ITEMS_PER_THREAD];
+        Size      selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE) {
+          BlockLoadItems(storage.load_items)
+              .Load(items_load_it + tile_base,
+                    items_loc,
+                    num_tile_items);
+        }
+        else
+        {
+          BlockLoadItems(storage.load_items)
+              .Load(items_load_it + tile_base,
+                    items_loc);
+        }
+
+        core::sync_threadblock();
+
+        if (USE_STENCIL)
+        {
+          stencil_type stencil_loc[ITEMS_PER_THREAD];
+
+          if (IS_LAST_TILE)
+          {
+            BlockLoadStencil(storage.load_stencil)
+                .Load(stencil_load_it + tile_base,
+                      stencil_loc,
+                      num_tile_items);
+          }
+          else
+          {
+            BlockLoadStencil(storage.load_stencil)
+                .Load(stencil_load_it + tile_base,
+                      stencil_loc);
+          }
+
+          compute_selection_flags<IS_LAST_TILE, STENCIL>(num_tile_items,
+                                                         stencil_loc,
+                                                         selection_flags);
+        }
+        else /* Use predicate on items rather then stencil */
+        {
+          compute_selection_flags<IS_LAST_TILE, ITEM>(num_tile_items,
+                                                      items_loc,
+                                                      selection_flags);
+        }
+
+        core::sync_threadblock();
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        core::sync_threadblock();
+
+        scatter(items_loc,
+                selection_flags,
+                selection_idx,
+                num_tile_selections,
+                num_selections_prefix);
+
+
+        return num_selections;
+      }    // func consume_tile_impl
+
+      template <bool         IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION Size
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }    // func consume_tile
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION impl(TempStorage &       storage_,
+                                  ScanTileState &     tile_state_,
+                                  ItemsIt             items_it,
+                                  StencilIt           stencil_it,
+                                  OutputIt            output_it_,
+                                  Predicate           predicate_,
+                                  Size                num_items_,
+                                  int                 num_tiles,
+                                  NumSelectedOutputIt num_selected_out)
+          : storage(storage_),
+            tile_state(tile_state_),
+            items_load_it(core::make_load_iterator(ptx_plan(), items_it)),
+            stencil_load_it(core::make_load_iterator(ptx_plan(), stencil_it)),
+            output_it(output_it_),
+            predicate(predicate_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }    // ctor impl
+    };
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ItemsIt             items_it,
+                       StencilIt           stencil_it,
+                       OutputIt            output_it,
+                       Predicate           predicate,
+                       Size                num_items,
+                       NumSelectedOutputIt num_selected_out,
+                       ScanTileState       tile_state,
+                       int                 num_tiles,
+                       char *              shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           items_it,
+           stencil_it,
+           output_it,
+           predicate,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  };    // struct CopyIfAgent
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char *        /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+  };    // struct InitAgent
+
+  template <class ItemsIt,
+            class StencilIt,
+            class OutputIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutIt>
+  THRUST_RUNTIME_FUNCTION
+  static cudaError_t doit_step(void *           d_temp_storage,
+                               size_t &         temp_storage_bytes,
+                               ItemsIt          items,
+                               StencilIt        stencil,
+                               OutputIt         output_it,
+                               Predicate        predicate,
+                               NumSelectedOutIt num_selected_out,
+                               Size             num_items,
+                               cudaStream_t     stream)
+  {
+    if (num_items == 0)
+      return cudaSuccess;
+
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        CopyIfAgent<ItemsIt,
+                    StencilIt,
+                    OutputIt,
+                    Predicate,
+                    Size,
+                    NumSelectedOutIt> >
+        copy_if_agent;
+
+    typedef typename copy_if_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type    init_plan    = init_agent::get_plan();
+    typename get_plan<copy_if_agent>::type copy_if_plan = copy_if_agent::get_plan(stream);
+
+    int tile_size = copy_if_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(copy_if_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    if (num_items == 0)
+      return status;
+
+    size_t allocation_sizes[2] = {0, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+
+    void* allocations[2] = {NULL, NULL};
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status = tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    init_agent ia(init_plan, num_tiles, stream, "copy_if::init_agent");
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char*)allocations[1] : NULL;
+
+    copy_if_agent pa(copy_if_plan, num_items, stream, vshmem_ptr, "copy_if::partition_agent");
+
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    pa.launch(items,
+              stencil,
+              output_it,
+              predicate,
+              num_items,
+              num_selected_out,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename InputIt,
+            typename StencilIt,
+            typename OutputIt,
+            typename Predicate>
+  THRUST_RUNTIME_FUNCTION
+  OutputIt copy_if(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   StencilIt                  stencil,
+                   OutputIt                   output,
+                   Predicate                  predicate)
+  {
+    typedef int size_type;
+
+    size_type    num_items          = static_cast<size_type>(thrust::distance(first, last));
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    if (num_items == 0)
+      return output;
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       output,
+                       predicate,
+                       reinterpret_cast<size_type*>(NULL),
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "copy_if failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "copy_if failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "copy_if failed on 2nd alias_storage");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       output,
+                       predicate,
+                       d_num_selected_out,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "copy_if failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "copy_if failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return output + num_selected;
+  }
+
+}    // namespace __copy_if
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIterator,
+          class OutputIterator,
+          class Predicate>
+OutputIterator __host__ __device__
+copy_if(execution_policy<Derived> &policy,
+        InputIterator              first,
+        InputIterator              last,
+        OutputIterator             result,
+        Predicate                  pred)
+{
+  THRUST_CDP_DISPATCH((return __copy_if::copy_if(policy,
+                                                   first,
+                                                   last,
+                                                   __copy_if::no_stencil_tag(),
+                                                   result,
+                                                   pred);),
+                      (return
+                         thrust::copy_if(cvt_to_seq(derived_cast(policy)),
+                                         first,
+                                         last,
+                                         result,
+                                         pred);));
+} // func copy_if
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIterator,
+          class StencilIterator,
+          class OutputIterator,
+          class Predicate>
+OutputIterator __host__ __device__
+copy_if(execution_policy<Derived> &policy,
+        InputIterator              first,
+        InputIterator              last,
+        StencilIterator            stencil,
+        OutputIterator             result,
+        Predicate                  pred)
+{
+  THRUST_CDP_DISPATCH(
+    (return __copy_if::copy_if(policy, first, last, stencil, result, pred);),
+    (return thrust::copy_if(cvt_to_seq(derived_cast(policy)),
+                              first,
+                              last,
+                              stencil,
+                              result,
+                              pred);));
+}    // func copy_if
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/copy.h>
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/agent_launcher.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/agent_launcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbb26f33f72bead999214f9a9a36cf5a7977ba3b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/agent_launcher.h
@@ -0,0 +1,1145 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <cub/detail/device_synchronize.cuh>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+#include <thrust/system/cuda/detail/core/triple_chevron_launch.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <cassert>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+namespace core {
+
+
+#if defined(__CUDA_ARCH__) || defined(_NVHPC_CUDA)
+#if 0
+  template <class Agent, class... Args>
+  void __global__
+  __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+      _kernel_agent(Args... args)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(args..., shmem);
+  }
+#else
+  template <class Agent, class _0>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, shmem);
+  }
+  template <class Agent, class _0, class _1>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, shmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE)
+  {
+    extern __shared__ char shmem[];
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE, shmem);
+  }
+#endif
+
+  ////////////////////////////////////////////////////////////
+
+
+#if 0
+  template <class Agent, class... Args>
+  void __global__
+  __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+      _kernel_agent_vshmem(char* vshmem, Args... args)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(args..., vshmem);
+  }
+#else
+  template <class Agent, class _0>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, vshmem);
+  }
+  template <class Agent, class _0, class _1>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, vshmem);
+  }
+  template <class Agent, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  void __global__ __launch_bounds__(Agent::ptx_plan::BLOCK_THREADS)
+  _kernel_agent_vshmem(char* vshmem, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE)
+  {
+    extern __shared__ char shmem[];
+    vshmem = vshmem == NULL ? shmem : vshmem + blockIdx.x * temp_storage_size<typename Agent::ptx_plan>::value;
+    Agent::entry(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE, vshmem);
+  }
+#endif
+#else
+#if 0
+  template <class , class... Args >
+  void __global__  _kernel_agent(Args... args) {}
+  template <class , class... Args >
+  void __global__  _kernel_agent_vshmem(char*, Args... args) {}
+#else
+  template <class, class _0>
+  void __global__ _kernel_agent(_0) {}
+  template <class, class _0, class _1>
+  void __global__ _kernel_agent(_0,_1) {}
+  template <class, class _0, class _1, class _2>
+  void __global__ _kernel_agent(_0,_1,_2) {}
+  template <class, class _0, class _1, class _2, class _3>
+  void __global__ _kernel_agent(_0,_1,_2,_3) {}
+  template <class, class _0, class _1, class _2, class _3, class _4>
+  void __global__ _kernel_agent(_0,_1,_2,_3, _4) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5>
+  void __global__ _kernel_agent(_0,_1,_2,_3, _4, _5) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  void __global__ _kernel_agent(_0,_1,_2,_3, _4, _5, _6) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  void __global__ _kernel_agent(_0,_1,_2,_3, _4, _5, _6, _7) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  void __global__ _kernel_agent(_0,_1,_2,_3, _4, _5, _6, _7, _8) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC, _xD) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  void __global__ _kernel_agent(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB,_xC, _xD, _xE) {}
+  ////////////////////////////////////////////////////////////
+  template <class, class _0>
+  void __global__ _kernel_agent_vshmem(char*,_0) {}
+  template <class, class _0, class _1>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1) {}
+  template <class, class _0, class _1, class _2>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2) {}
+  template <class, class _0, class _1, class _2, class _3>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3) {}
+  template <class, class _0, class _1, class _2, class _3, class _4>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6, _7) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+  void __global__ _kernel_agent_vshmem(char*,_0,_1,_2,_3, _4, _5, _6, _7, _8) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD) {}
+  template <class, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+  void __global__ _kernel_agent_vshmem(char*,_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE) {}
+#endif
+#endif
+
+
+  template<class Agent>
+  struct AgentLauncher : Agent
+  {
+    core::AgentPlan plan;
+    size_t          count;
+    cudaStream_t    stream;
+    char const*     name;
+    unsigned int    grid;
+    char*           vshmem;
+    bool            has_shmem;
+    size_t          shmem_size;
+
+    enum
+    {
+      MAX_SHMEM_PER_BLOCK = 48 * 1024,
+    };
+    typedef
+        typename has_enough_shmem<Agent,
+                                  MAX_SHMEM_PER_BLOCK>::type has_enough_shmem_t;
+    typedef
+        has_enough_shmem<Agent,
+                                  MAX_SHMEM_PER_BLOCK> shm1;
+
+    template <class Size>
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  Size         count_,
+                  cudaStream_t stream_,
+                  char const*  name_)
+        : plan(plan_),
+          count((size_t)count_),
+          stream(stream_),
+          name(name_),
+          grid(static_cast<unsigned int>((count + plan.items_per_tile - 1) / plan.items_per_tile)),
+          vshmem(NULL),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(count > 0);
+    }
+
+    template <class Size>
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  Size         count_,
+                  cudaStream_t stream_,
+                  char*        vshmem,
+                  char const*  name_)
+        : plan(plan_),
+          count((size_t)count_),
+          stream(stream_),
+          name(name_),
+          grid(static_cast<unsigned int>((count + plan.items_per_tile - 1) / plan.items_per_tile)),
+          vshmem(vshmem),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(count > 0);
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  cudaStream_t stream_,
+                  char const*  name_)
+        : plan(plan_),
+          count(0),
+          stream(stream_),
+          name(name_),
+          grid(plan.grid_size),
+          vshmem(NULL),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(plan.grid_size > 0);
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    AgentLauncher(AgentPlan    plan_,
+                  cudaStream_t stream_,
+                  char*        vshmem,
+                  char const*  name_)
+        : plan(plan_),
+          count(0),
+          stream(stream_),
+          name(name_),
+          grid(plan.grid_size),
+          vshmem(vshmem),
+          has_shmem((size_t)core::get_max_shared_memory_per_block() >= (size_t)plan.shared_memory_size),
+          shmem_size(has_shmem ? plan.shared_memory_size : 0)
+    {
+      assert(plan.grid_size > 0);
+    }
+
+#if 0
+    THRUST_RUNTIME_FUNCTION
+    AgentPlan static get_plan(cudaStream_t s, void* d_ptr = 0)
+    {
+      // in separable compilation mode, we have no choice
+      // but to call kernel to get agent_plan
+      // otherwise the risk is something may fail
+      // if user mix & match ptx versions in a separably compiled function
+      // http://nvbugs/1772071
+      // XXX may be it is too string of a requirements, consider relaxing it in
+      // the future
+#ifdef __CUDACC_RDC__
+      return core::get_agent_plan<Agent>(s, d_ptr);
+#else
+      return get_agent_plan<Agent>(core::get_ptx_version());
+#endif
+    }
+    THRUST_RUNTIME_FUNCTION
+    AgentPlan static get_plan_default()
+    {
+      return get_agent_plan<Agent>(sm_arch<0>::type::ver);
+    }
+#endif
+
+    THRUST_RUNTIME_FUNCTION
+    typename core::get_plan<Agent>::type static get_plan(cudaStream_t , void* d_ptr = 0)
+    {
+      THRUST_UNUSED_VAR(d_ptr);
+      return get_agent_plan<Agent>(core::get_ptx_version());
+    }
+
+    THRUST_RUNTIME_FUNCTION
+    typename core::get_plan<Agent>::type static get_plan()
+    {
+      return get_agent_plan<Agent>(lowest_supported_sm_arch::ver);
+    }
+
+    THRUST_RUNTIME_FUNCTION void sync() const
+    {
+      CubDebug(cub::detail::DebugSyncStream(stream));
+    }
+
+    template<class K>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    max_blocks_per_sm_impl(K k, int block_threads)
+    {
+      int occ;
+      cudaError_t status = cub::MaxSmOccupancy(occ, k, block_threads);
+      return cuda_optional<int>(status == cudaSuccess ? occ : -1, status);
+    }
+
+    template <class K>
+    cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    max_sm_occupancy(K k) const
+    {
+      return max_blocks_per_sm_impl(k, plan.block_threads);
+    }
+
+    template<class K>
+    THRUST_RUNTIME_FUNCTION
+    void print_info(K k) const
+    {
+      #if THRUST_DEBUG_SYNC_FLAG 
+      cuda_optional<int> occ = max_sm_occupancy(k);
+      const int ptx_version = core::get_ptx_version();
+      if (count > 0)
+      {
+        _CubLog("Invoking %s<<<%u, %d, %d, %lld>>>(), %llu items total, %d items per thread, %d SM occupancy, %d vshmem size, %d ptx_version \n",
+                name,
+                grid,
+                plan.block_threads,
+                (has_shmem ? (int)plan.shared_memory_size : 0),
+                (long long)stream,
+                (long long)count,
+                plan.items_per_thread,
+                (int)occ,
+                (!has_shmem ? (int)plan.shared_memory_size : 0),
+                (int)ptx_version);
+      }
+      else
+      {
+        _CubLog("Invoking %s<<<%u, %d, %d, %lld>>>(), %d items per thread, %d SM occupancy, %d vshmem size, %d ptx_version\n",
+                name,
+                grid,
+                plan.block_threads,
+                (has_shmem ? (int)plan.shared_memory_size : 0),
+                (long long)stream,
+                plan.items_per_thread,
+                (int)occ,
+                (!has_shmem ? (int)plan.shared_memory_size : 0),
+                (int)ptx_version);
+      }
+      #else
+      (void)k;
+      #endif
+    }
+
+    ////////////////////
+    //  Variadic code
+    ////////////////////
+
+#if 0
+    template<class... Args>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      return max_blocks_per_sm_impl(_kernel_agent<Agent, Args...>, plan.block_threads);
+    }
+#else
+    template<class _0>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0) = _kernel_agent<Agent, _0>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0, _1) = _kernel_agent<Agent, _0, _1>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2) = _kernel_agent<Agent, _0, _1, _2>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3) = _kernel_agent<Agent, _0, _1, _2,_3>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4) = _kernel_agent<Agent, _0, _1, _2,_3,_4>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+    template<class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    static cuda_optional<int> THRUST_RUNTIME_FUNCTION
+    get_max_blocks_per_sm(AgentPlan plan)
+    {
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE>;
+      return max_blocks_per_sm_impl(ptr, plan.block_threads);
+    }
+#endif
+
+
+
+#if 0
+
+    // If we are guaranteed to have enough shared memory
+    // don't compile other kernel which accepts pointer
+    // and save on compilations
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, Args... args) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      print_info(_kernel_agent<Agent, Args...>);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(_kernel_agent<Agent, Args...>, args...);
+    }
+
+    // If there is a risk of not having enough shared memory
+    // we compile generic kernel instead.
+    // This kernel is likely to be somewhat slower, but it can accomodate
+    // both shared and virtualized shared memories.
+    // Alternative option is to compile two kernels, one using shared and one
+    // using virtualized shared memory. While this can be slightly faster if we
+    // do actually have enough shared memory, the compilation time will double.
+    //
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, Args... args) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      print_info(_kernel_agent_vshmem<Agent, Args...>);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(_kernel_agent_vshmem<Agent, Args...>, vshmem, args...);
+    }
+
+    template <class... Args>
+    void THRUST_RUNTIME_FUNCTION
+    launch(Args... args) const
+    {
+      launch_impl(has_enough_shmem_t(),args...);
+      sync();
+    }
+#else
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0) = _kernel_agent_vshmem<Agent, _0>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0);
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1) = _kernel_agent_vshmem<Agent, _0, _1>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1);
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2) = _kernel_agent_vshmem<Agent, _0, _1, _2>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2);
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3);
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8>;
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC,_xD xD) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::false_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9,_xA xA,_xB xB,_xC xC,_xD xD,_xE xE) const
+    {
+      assert((has_shmem && vshmem == NULL) || (!has_shmem && vshmem != NULL && shmem_size == 0));
+      void (*ptr)(char*, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE) = _kernel_agent_vshmem<Agent, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _xA, _xB, _xC, _xD, _xE>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, shmem_size, stream)
+          .doit(ptr, vshmem, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+    }
+
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0) = _kernel_agent<Agent, _0>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0);
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0, _1) = _kernel_agent<Agent, _0, _1>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1);
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2) = _kernel_agent<Agent, _0, _1, _2>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2);
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3) = _kernel_agent<Agent, _0, _1, _2,_3>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3);
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4) = _kernel_agent<Agent, _0, _1, _2,_3,_4>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch_impl(thrust::detail::true_type, _0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE) const
+    {
+      assert(has_shmem && vshmem == NULL);
+      void (*ptr)(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE) = _kernel_agent<Agent, _0, _1, _2,_3,_4,_5,_6,_7,_8,_9,_xA,_xB,_xC,_xD,_xE>;
+      print_info(ptr);
+      launcher::triple_chevron(grid, plan.block_threads, plan.shared_memory_size, stream)
+          .doit(ptr,x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+    }
+
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////
+
+    template <class _0>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0) const
+    {
+      launch_impl(has_enough_shmem_t(), x0);
+      sync();
+    }
+    template <class _0, class _1>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1);
+      sync();
+    }
+    template <class _0, class _1, class _2>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD);
+      sync();
+    }
+    template <class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9, class _xA, class _xB, class _xC, class _xD, class _xE>
+    void THRUST_RUNTIME_FUNCTION
+    launch(_0 x0, _1 x1, _2 x2, _3 x3, _4 x4, _5 x5, _6 x6, _7 x7, _8 x8, _9 x9, _xA xA, _xB xB, _xC xC, _xD xD, _xE xE) const
+    {
+      launch_impl(has_enough_shmem_t(), x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE);
+      sync();
+    }
+#endif
+
+
+  };
+
+}    // namespace core
+}
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/alignment.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/alignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b807ebc1eeda68455fa0b5e2efd91e75e205693
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/alignment.h
@@ -0,0 +1,250 @@
+/*
+ *  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.
+ */
+
+// TODO: This can probably be removed.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+namespace alignment_of_detail {
+
+
+  template <typename T>
+  class alignment_of_impl;
+
+  template <typename T, std::size_t size_diff>
+  struct helper
+  {
+    static const std::size_t value = size_diff;
+  };
+
+  template <typename T>
+  class helper<T, 0>
+  {
+  public:
+    static const std::size_t value = alignment_of_impl<T>::value;
+  };
+
+  template <typename T>
+  class alignment_of_impl
+  {
+  private:
+    struct big
+    {
+      T    x;
+      char c;
+    };
+
+  public:
+    static const std::size_t value = helper<big, sizeof(big) - sizeof(T)>::value;
+  };
+
+
+}    // end alignment_of_detail
+
+
+template <typename T>
+struct alignment_of
+    : alignment_of_detail::alignment_of_impl<T>
+{
+};
+
+
+template <std::size_t Align>
+struct aligned_type;
+
+// __align__ is CUDA-specific, so guard it
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+// implementing aligned_type portably is tricky:
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+// implement aligned_type with specialization because MSVC
+// requires literals as arguments to declspec(align(n))
+template <>
+struct aligned_type<1>
+{
+  struct __align__(1) type{};
+};
+
+template <>
+struct aligned_type<2>
+{
+  struct __align__(2) type{};
+};
+
+template <>
+struct aligned_type<4>
+{
+  struct __align__(4) type{};
+};
+
+template <>
+struct aligned_type<8>
+{
+  struct __align__(8) type{};
+};
+
+template <>
+struct aligned_type<16>
+{
+  struct __align__(16) type{};
+};
+
+template <>
+struct aligned_type<32>
+{
+  struct __align__(32) type{};
+};
+
+template <>
+struct aligned_type<64>
+{
+  struct __align__(64) type{};
+};
+
+template <>
+struct aligned_type<128>
+{
+  struct __align__(128) type{};
+};
+
+template <>
+struct aligned_type<256>
+{
+  struct __align__(256) type{};
+};
+
+template <>
+struct aligned_type<512>
+{
+  struct __align__(512) type{};
+};
+
+template <>
+struct aligned_type<1024>
+{
+  struct __align__(1024) type{};
+};
+
+template <>
+struct aligned_type<2048>
+{
+  struct __align__(2048) type{};
+};
+
+template <>
+struct aligned_type<4096>
+{
+  struct __align__(4096) type{};
+};
+
+template <>
+struct aligned_type<8192>
+{
+  struct __align__(8192) type{};
+};
+#elif (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION < 40300)
+// implement aligned_type with specialization because gcc 4.2
+// requires literals as arguments to __attribute__(aligned(n))
+template <>
+struct aligned_type<1>
+{
+  struct __align__(1) type{};
+};
+
+template <>
+struct aligned_type<2>
+{
+  struct __align__(2) type{};
+};
+
+template <>
+struct aligned_type<4>
+{
+  struct __align__(4) type{};
+};
+
+template <>
+struct aligned_type<8>
+{
+  struct __align__(8) type{};
+};
+
+template <>
+struct aligned_type<16>
+{
+  struct __align__(16) type{};
+};
+
+template <>
+struct aligned_type<32>
+{
+  struct __align__(32) type{};
+};
+
+template <>
+struct aligned_type<64>
+{
+  struct __align__(64) type{};
+};
+
+template <>
+struct aligned_type<128>
+{
+  struct __align__(128) type{};
+};
+
+#else
+// assume the compiler allows template parameters as
+// arguments to __align__
+template <std::size_t Align>
+struct aligned_type
+{
+  struct __align__(Align) type{};
+};
+#endif    // THRUST_HOST_COMPILER
+#else
+template <std::size_t Align>
+struct aligned_type
+{
+  struct type
+  {
+  };
+};
+#endif    // THRUST_DEVICE_COMPILER
+
+
+template <std::size_t Len, std::size_t Align>
+struct aligned_storage
+{
+  union type
+  {
+    unsigned char data[Len];
+
+    typename aligned_type<Align>::type align;
+  };
+};
+
+
+}    // end cuda_
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/triple_chevron_launch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/triple_chevron_launch.h
new file mode 100644
index 0000000000000000000000000000000000000000..65a7283b7420b1f8af0bf48b4aa8ae28d41b2288
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/triple_chevron_launch.h
@@ -0,0 +1,152 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/detail/core/alignment.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+#include <cassert>
+
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+namespace launcher {
+
+  struct triple_chevron
+  {
+    typedef size_t Size;
+    dim3 const grid;
+    dim3 const block;
+    Size const shared_mem;
+    cudaStream_t const stream;
+
+    THRUST_RUNTIME_FUNCTION
+    triple_chevron(dim3         grid_,
+                   dim3         block_,
+                   Size         shared_mem_ = 0,
+                   cudaStream_t stream_     = 0)
+        : grid(grid_),
+          block(block_),
+          shared_mem(shared_mem_),
+          stream(stream_) {}
+
+    template<class K, class... Args>
+    cudaError_t __host__
+    doit_host(K k, Args const&... args) const
+    {
+      k<<<grid, block, shared_mem, stream>>>(args...);
+      return cudaPeekAtLastError();
+    }
+
+    template<class T>
+    size_t __device__
+    align_up(size_t offset) const
+    {
+      size_t alignment = alignment_of<T>::value;
+      return alignment * ((offset + (alignment - 1))/ alignment);
+    }
+
+    size_t __device__ argument_pack_size(size_t size) const { return size; }
+    template <class Arg, class... Args>
+    size_t __device__
+    argument_pack_size(size_t size, Arg const& arg, Args const&... args) const
+    {
+      size = align_up<Arg>(size);
+      return argument_pack_size(size + sizeof(Arg), args...);
+    }
+
+    template <class Arg>
+    size_t __device__ copy_arg(char* buffer, size_t offset, Arg arg) const
+    {
+      offset = align_up<Arg>(offset);
+      for (int i = 0; i != sizeof(Arg); ++i)
+        buffer[offset+i] = *((char*)&arg + i);
+      return offset + sizeof(Arg);
+    }
+
+    __device__
+    void fill_arguments(char*, size_t) const
+    {}
+
+    template<class Arg, class... Args>
+    __device__
+    void fill_arguments(char* buffer,
+                     size_t offset,
+                     Arg const& arg,
+                     Args const& ... args) const
+    {
+      fill_arguments(buffer, copy_arg(buffer, offset, arg), args...);
+    }
+
+    #ifdef THRUST_RDC_ENABLED
+    template<class K, class... Args>
+    cudaError_t __device__
+    doit_device(K k, Args const&... args) const
+    {
+      const size_t size = argument_pack_size(0,args...);
+      void *param_buffer = cudaGetParameterBuffer(64,size);
+      fill_arguments((char*)param_buffer, 0, args...);
+      return launch_device(k, param_buffer);
+    }
+
+    template <class K>
+    cudaError_t __device__
+    launch_device(K k, void* buffer) const
+    {
+      return cudaLaunchDevice((void*)k,
+                              buffer,
+                              dim3(grid),
+                              dim3(block),
+                              shared_mem,
+                              stream);
+    }
+    #else 
+    template<class K, class... Args>
+    cudaError_t __device__
+    doit_device(K, Args const&... ) const
+    {
+      return cudaErrorNotSupported;
+    }
+    #endif
+
+    __thrust_exec_check_disable__
+    template <class K, class... Args>
+    THRUST_FUNCTION
+    cudaError_t doit(K k, Args const&... args) const
+    {
+      NV_IF_TARGET(NV_IS_HOST,
+                   (return doit_host(k, args...);),
+                   (return doit_device(k, args...);));
+    }
+
+  }; // struct triple_chevron
+
+}    // namespace launcher
+}    // namespace cuda_
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2f5f8299e4ab09b956d4af2a092998f6bbb48d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/core/util.h
@@ -0,0 +1,802 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/system_error.h>
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_scan.cuh>
+#include <cub/block/block_store.cuh>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+namespace core {
+
+#ifdef _NVHPC_CUDA
+#  if (__NVCOMPILER_CUDA_ARCH__ >= 600)
+#    define THRUST_TUNING_ARCH sm60
+#  elif (__NVCOMPILER_CUDA_ARCH__ >= 520)
+#    define THRUST_TUNING_ARCH sm52
+#  elif (__NVCOMPILER_CUDA_ARCH__ >= 350)
+#    define THRUST_TUNING_ARCH sm35
+#  else
+#    define THRUST_TUNING_ARCH sm30
+#  endif
+#else
+#  if (__CUDA_ARCH__ >= 600)
+#    define THRUST_TUNING_ARCH sm60
+#  elif (__CUDA_ARCH__ >= 520)
+#    define THRUST_TUNING_ARCH sm52
+#  elif (__CUDA_ARCH__ >= 350)
+#    define THRUST_TUNING_ARCH sm35
+#  elif (__CUDA_ARCH__ >= 300)
+#    define THRUST_TUNING_ARCH sm30
+#  elif !defined (__CUDA_ARCH__)
+#    define THRUST_TUNING_ARCH sm30
+#  endif
+#endif
+
+  // Typelist - a container of types, supports up to 10 types
+  // --------------------------------------------------------------------------
+
+  class _;
+  template <class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _, class = _>
+  struct typelist;
+
+  // -------------------------------------
+
+  // supported SM arch
+  // ---------------------
+  struct sm30  { enum { ver = 300, warpSize = 32 }; };
+  struct sm35  { enum { ver = 350, warpSize = 32 }; };
+  struct sm52  { enum { ver = 520, warpSize = 32 }; };
+  struct sm60  { enum { ver = 600, warpSize = 32 }; };
+
+  // list of sm, checked from left to right order
+  // the rightmost is the lowest sm arch supported
+  // --------------------------------------------
+  typedef typelist<sm60,sm52,sm35,sm30> sm_list;
+
+  // lowest supported SM arch
+  // --------------------------------------------------------------------------
+
+  template<class, class>
+  struct lowest_supported_sm_arch_impl;
+
+  template <class SM, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct lowest_supported_sm_arch_impl<SM, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : lowest_supported_sm_arch_impl<_0, typelist<    _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+  template <class SM>
+  struct lowest_supported_sm_arch_impl<SM, typelist<> >
+  {
+    typedef SM type;
+  };
+
+  typedef typename lowest_supported_sm_arch_impl<_,sm_list>::type lowest_supported_sm_arch;
+
+  // metafunction to match next viable PtxPlan specialization
+  // --------------------------------------------------------------------------
+
+  __THRUST_DEFINE_HAS_NESTED_TYPE(has_tuning_t, tuning)
+  __THRUST_DEFINE_HAS_NESTED_TYPE(has_type_t, type)
+
+  template <template <class> class, class, class>
+  struct specialize_plan_impl_loop;
+  template <template <class> class, class>
+  struct specialize_plan_impl_match;
+
+  // we loop through the sm_list
+  template <template <class> class P, class SM, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_loop<P, SM, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : specialize_plan_impl_loop<P, SM, typelist<    _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+
+  // until we find first lowest match
+  template <template <class> class P, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_loop <P, SM,  typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+       : specialize_plan_impl_match<P,      typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> > {};
+
+  template<class, class>
+  struct has_sm_tuning_impl;
+
+  // specializing for Tunig which needs 1 arg
+  template <class SM,
+            template <class, class> class Tuning,
+            class _0>
+  struct has_sm_tuning_impl<SM, Tuning<lowest_supported_sm_arch, _0> > : has_type_t<Tuning<SM, _0> > {};
+
+  // specializing for Tunig which needs 2 args
+  template <class SM,
+            template <class, class,class> class Tuning,
+            class _0, class _1>
+  struct has_sm_tuning_impl<SM, Tuning<lowest_supported_sm_arch, _0, _1> > : has_type_t<Tuning<SM, _0, _1> > {};
+
+  template <template <class> class P, class SM>
+  struct has_sm_tuning : has_sm_tuning_impl<SM, typename P<lowest_supported_sm_arch>::tuning > {};
+
+  // once first match is found in sm_list, all remaining sm are possible
+  // candidate for tuning, so pick the first available
+  //   if the plan P has SM-level tuning then pick it,
+  //   otherwise move on to the next sm in the sm_list
+  template <template <class> class P, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+  struct specialize_plan_impl_match<P, typelist<SM, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+      : thrust::detail::conditional<
+            has_sm_tuning<P, SM>::value,
+            P<SM>,
+            specialize_plan_impl_match<P, typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> > >::type {};
+
+    template <template <class> class Plan, class SM = THRUST_TUNING_ARCH>
+    struct specialize_plan_msvc10_war
+    {
+      // if Plan has tuning type, this means it has SM-specific tuning
+      // so loop through sm_list to find match,
+      // otherwise just specialize on provided SM
+      typedef thrust::detail::conditional<has_tuning_t<Plan<lowest_supported_sm_arch> >::value,
+                                  specialize_plan_impl_loop<Plan, SM, sm_list>,
+                                  Plan<SM> >
+          type;
+    };
+
+    template <template <class> class Plan, class SM = THRUST_TUNING_ARCH>
+    struct specialize_plan : specialize_plan_msvc10_war<Plan,SM>::type::type {};
+
+
+    /////////////////////////
+    /////////////////////////
+    /////////////////////////
+
+    // retrieve temp storage size from an Agent
+    // ---------------------------------------------------------------------------
+    // metafunction introspects Agent, and if it finds TempStorage type
+    // it will return its size
+
+    __THRUST_DEFINE_HAS_NESTED_TYPE(has_temp_storage, TempStorage)
+
+    template <class Agent, class U>
+    struct temp_storage_size_impl;
+
+    template <class Agent>
+    struct temp_storage_size_impl<Agent, thrust::detail::false_type>
+    {
+      enum
+      {
+        value = 0
+      };
+    };
+
+    template <class Agent>
+    struct temp_storage_size_impl<Agent, thrust::detail::true_type>
+    {
+      enum
+      {
+        value = sizeof(typename Agent::TempStorage)
+      };
+    };
+
+    template <class Agent>
+    struct temp_storage_size
+        : temp_storage_size_impl<Agent, typename has_temp_storage<Agent>::type>
+    {
+    };
+
+    // check whether all Agents requires < MAX_SHMEM shared memory
+    // ---------------------------------------------------------------------------
+    // if so, we can use simpler kernel for dispatch, which assumes that all
+    // shared memory is on chip.
+    // Otherwise, a kernel will be compiled which can also accept virtualized
+    // shared memory, in case there is not enough on chip. This kernel is about
+    // 10% slower
+
+    template <bool, class, size_t, class>
+    struct has_enough_shmem_impl;
+
+    template <bool V, class A, size_t S, class _0, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    struct has_enough_shmem_impl<V, A, S, typelist<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> >
+        : has_enough_shmem_impl<
+              V && (temp_storage_size<specialize_plan<A::template PtxPlan, _0> >::value <= S),
+              A,
+              S,
+              typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> >
+    {
+    };
+    template <bool V, class A, size_t S>
+    struct has_enough_shmem_impl<V, A, S, typelist<> >
+    {
+      enum
+      {
+        value = V
+      };
+      typedef typename thrust::detail::conditional<value,
+                                           thrust::detail::true_type,
+                                           thrust::detail::false_type>::type type;
+    };
+
+    template <class Agent, size_t MAX_SHMEM>
+    struct has_enough_shmem : has_enough_shmem_impl<true, Agent, MAX_SHMEM, sm_list>
+    {
+    };
+
+    /////////////////////////
+    /////////////////////////
+    /////////////////////////
+
+    // AgentPlan structure and helpers
+    // --------------------------------
+
+    struct AgentPlan
+    {
+      int block_threads;
+      int items_per_thread;
+      int items_per_tile;
+      int shared_memory_size;
+      int grid_size;
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan() {}
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(int block_threads_,
+                int items_per_thread_,
+                int shared_memory_size_,
+                int grid_size_ = 0)
+          : block_threads(block_threads_),
+            items_per_thread(items_per_thread_),
+            items_per_tile(items_per_thread * block_threads),
+            shared_memory_size(shared_memory_size_),
+            grid_size(grid_size_)
+      {
+      }
+
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(AgentPlan const& plan)
+          : block_threads(plan.block_threads),
+            items_per_thread(plan.items_per_thread),
+            items_per_tile(plan.items_per_tile),
+            shared_memory_size(plan.shared_memory_size),
+            grid_size(plan.grid_size) {}
+
+      template <class PtxPlan>
+      THRUST_RUNTIME_FUNCTION
+      AgentPlan(PtxPlan,
+                typename thrust::detail::disable_if_convertible<
+                    PtxPlan,
+                    AgentPlan>::type* = NULL)
+          : block_threads(PtxPlan::BLOCK_THREADS),
+            items_per_thread(PtxPlan::ITEMS_PER_THREAD),
+            items_per_tile(PtxPlan::ITEMS_PER_TILE),
+            shared_memory_size(temp_storage_size<PtxPlan>::value),
+            grid_size(0)
+      {
+      }
+    };    // struct AgentPlan
+
+
+    __THRUST_DEFINE_HAS_NESTED_TYPE(has_Plan, Plan)
+
+    template <class Agent>
+    struct return_Plan
+    {
+      typedef typename Agent::Plan type;
+    };
+
+    template <class Agent>
+    struct get_plan : thrust::detail::conditional<
+                          has_Plan<Agent>::value,
+                          return_Plan<Agent>,
+                          thrust::detail::identity_<AgentPlan> >::type
+    {
+    };
+
+    // returns AgentPlan corresponding to a given ptx version
+    // ------------------------------------------------------
+
+    template<class, class>
+    struct get_agent_plan_impl;
+
+    template<class Agent, class SM, class _1, class _2, class _3, class _4, class _5, class _6, class _7, class _8, class _9>
+    struct get_agent_plan_impl<Agent,typelist<SM,_1,_2,_3,_4,_5,_6,_7,_8,_9> >
+    {
+      typedef typename get_plan<Agent>::type Plan;
+      Plan THRUST_RUNTIME_FUNCTION
+      static get(int ptx_version)
+      {
+        if (ptx_version >= SM::ver)
+          return Plan(specialize_plan<Agent::template PtxPlan, SM>());
+        else
+          return get_agent_plan_impl<Agent,
+                                     typelist<_1, _2, _3, _4, _5, _6, _7, _8, _9> >::
+              get(ptx_version);
+      }
+    };
+
+    template<class Agent>
+    struct get_agent_plan_impl<Agent,typelist<lowest_supported_sm_arch> >
+    {
+      typedef typename get_plan<Agent>::type Plan;
+      Plan THRUST_RUNTIME_FUNCTION
+      static get(int /* ptx_version */)
+      {
+        typedef typename get_plan<Agent>::type Plan;
+        return Plan(specialize_plan<Agent::template PtxPlan, lowest_supported_sm_arch>());
+      }
+    };
+
+    template <class Agent>
+    THRUST_RUNTIME_FUNCTION
+    typename get_plan<Agent>::type get_agent_plan(int ptx_version)
+    {
+      NV_IF_TARGET(
+        NV_IS_DEVICE,
+        (
+          THRUST_UNUSED_VAR(ptx_version);
+          using plan_type = typename get_plan<Agent>::type;
+          using ptx_plan  = typename Agent::ptx_plan;
+          return plan_type{ptx_plan{}};
+        ), // NV_IS_HOST:
+        ( return get_agent_plan_impl<Agent, sm_list>::get(ptx_version); ));
+    }
+
+// XXX keep this dead-code for now as a gentle reminder
+//     that kernel luunch which reats plan values is the most robust
+//     mechanism to extract sm-specific tuning parameters
+// TODO: since we are unable to afford kernel launch + cudaMemcpy ON EVERY
+//       algorithm invocation, we need to design a good caching strategy
+//       such that when the algorithm is called multiple times, only the
+//       first invocation will invoke kernel launch + cudaMemcpy, but
+//       the subsequent invocations, will just read cached values from host mem
+//       If launched from device, this is just a device-function call
+//       no caching is required.
+// ----------------------------------------------------------------------------
+  // if we don't know ptx version, we can call kernel
+  // to retrieve AgentPlan from device code. Slower, but guaranteed to work
+  // -----------------------------------------------------------------------
+#if 0
+  template<class Agent>
+  void __global__ get_agent_plan_kernel(AgentPlan *plan);
+
+  static __device__ AgentPlan agent_plan_device;
+
+  template<class Agent>
+  AgentPlan __device__ get_agent_plan_dev()
+  {
+    AgentPlan plan;
+    plan.block_threads      = Agent::ptx_plan::BLOCK_THREADS;
+    plan.items_per_thread   = Agent::ptx_plan::ITEMS_PER_THREAD;
+    plan.items_per_tile     = Agent::ptx_plan::ITEMS_PER_TILE;
+    plan.shared_memory_size = temp_storage_size<typename Agent::ptx_plan>::value;
+    return plan;
+  }
+
+  template <class Agent, class F>
+  AgentPlan __host__ __device__ __forceinline__
+  xget_agent_plan_impl(F f, cudaStream_t s, void* d_ptr)
+  {
+    AgentPlan plan;
+#ifdef __CUDA_ARCH__
+    plan = get_agent_plan_dev<Agent>();
+#else
+    static cub::Mutex mutex;
+    bool lock = false;
+    if (d_ptr == 0)
+    {
+      lock = true;
+      cudaGetSymbolAddress(&d_ptr, agent_plan_device);
+    }
+    if (lock)
+      mutex.Lock();
+    f<<<1,1,0,s>>>((AgentPlan*)d_ptr);
+    cudaMemcpyAsync((void*)&plan,
+                    d_ptr,
+                    sizeof(AgentPlan),
+                    cudaMemcpyDeviceToHost,
+                    s);
+    if (lock)
+      mutex.Unlock();
+    cudaStreamSynchronize(s);
+#endif
+    return plan;
+  }
+
+  template <class Agent>
+  AgentPlan THRUST_RUNTIME_FUNCTION
+  get_agent_plan(cudaStream_t s = 0, void *ptr = 0)
+  {
+    return xget_agent_plan_impl<Agent>(get_agent_plan_kernel<Agent>,
+                                        s,
+                                        ptr);
+  }
+
+  template<class Agent>
+  void __global__ get_agent_plan_kernel(AgentPlan *plan)
+  {
+    *plan = get_agent_plan_dev<Agent>();
+  }
+#endif
+
+  /////////////////////////
+  /////////////////////////
+  /////////////////////////
+
+  THRUST_RUNTIME_FUNCTION
+  inline int get_sm_count()
+  {
+    int dev_id;
+    cuda_cub::throw_on_error(cudaGetDevice(&dev_id),
+                             "get_sm_count :"
+                             "failed to cudaGetDevice");
+
+    cudaError_t status;
+    int         i32value;
+    status = cudaDeviceGetAttribute(&i32value,
+                                    cudaDevAttrMultiProcessorCount,
+                                    dev_id);
+    cuda_cub::throw_on_error(status,
+                             "get_sm_count:"
+                             "failed to sm_count");
+    return i32value;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t get_max_shared_memory_per_block()
+  {
+    int dev_id;
+    cuda_cub::throw_on_error(cudaGetDevice(&dev_id),
+                             "get_max_shared_memory_per_block :"
+                             "failed to cudaGetDevice");
+
+    cudaError_t status;
+    int         i32value;
+    status = cudaDeviceGetAttribute(&i32value,
+                                    cudaDevAttrMaxSharedMemoryPerBlock,
+                                    dev_id);
+    cuda_cub::throw_on_error(status,
+                             "get_max_shared_memory_per_block :"
+                             "failed to get max shared memory per block");
+
+    return static_cast<size_t>(i32value);
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t virtual_shmem_size(size_t shmem_per_block)
+  {
+    size_t max_shmem_per_block = core::get_max_shared_memory_per_block();
+    if (shmem_per_block > max_shmem_per_block)
+      return shmem_per_block;
+    else
+      return 0;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline size_t vshmem_size(size_t shmem_per_block, size_t num_blocks)
+  {
+    size_t max_shmem_per_block = core::get_max_shared_memory_per_block();
+    if (shmem_per_block > max_shmem_per_block)
+      return shmem_per_block*num_blocks;
+    else
+      return 0;
+  }
+
+  // LoadIterator
+  // ------------
+  // if trivial iterator is passed, wrap loads into LDG
+  //
+  template <class PtxPlan, class It>
+  struct LoadIterator
+  {
+    typedef typename iterator_traits<It>::value_type      value_type;
+    typedef typename iterator_traits<It>::difference_type size_type;
+
+    typedef typename thrust::detail::conditional<
+        is_contiguous_iterator<It>::value,
+        cub::CacheModifiedInputIterator<PtxPlan::LOAD_MODIFIER,
+                                        value_type,
+                                        size_type>,
+                                        It>::type type;
+  };    // struct Iterator
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator_impl(It it, thrust::detail::true_type /* is_trivial */)
+  {
+    return raw_pointer_cast(&*it);
+  }
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator_impl(It it, thrust::detail::false_type /* is_trivial */)
+  {
+    return it;
+  }
+
+  template <class PtxPlan, class It>
+  typename LoadIterator<PtxPlan, It>::type __device__ __forceinline__
+  make_load_iterator(PtxPlan const&, It it)
+  {
+    return make_load_iterator_impl<PtxPlan>(
+        it, typename is_contiguous_iterator<It>::type());
+  }
+
+  template<class>
+  struct get_arch;
+
+  template<template<class> class Plan, class Arch>
+  struct get_arch<Plan<Arch> > { typedef Arch type; };
+
+  // BlockLoad
+  // -----------
+  // a helper metaprogram that returns type of a block loader
+  template <class PtxPlan,
+            class It,
+            class T    = typename iterator_traits<It>::value_type>
+  struct BlockLoad
+  {
+    using type = cub::BlockLoad<T,
+                                PtxPlan::BLOCK_THREADS,
+                                PtxPlan::ITEMS_PER_THREAD,
+                                PtxPlan::LOAD_ALGORITHM,
+                                1,
+                                1,
+                                get_arch<PtxPlan>::type::ver>;
+  };
+
+  // BlockStore
+  // -----------
+  // a helper metaprogram that returns type of a block loader
+  template <class PtxPlan,
+            class It,
+            class T = typename iterator_traits<It>::value_type>
+  struct BlockStore
+  {
+    using type = cub::BlockStore<T,
+                                 PtxPlan::BLOCK_THREADS,
+                                 PtxPlan::ITEMS_PER_THREAD,
+                                 PtxPlan::STORE_ALGORITHM,
+                                 1,
+                                 1,
+                                 get_arch<PtxPlan>::type::ver>;
+  };
+
+  // cuda_optional
+  // --------------
+  // used for function that return cudaError_t along with the result
+  //
+  template <class T>
+  class cuda_optional
+  {
+    cudaError_t status_{cudaSuccess};
+    T           value_{};
+
+  public:
+    cuda_optional() = default;
+
+    __host__ __device__
+    cuda_optional(T v, cudaError_t status = cudaSuccess) : status_(status), value_(v) {}
+
+    bool __host__ __device__
+    isValid() const { return cudaSuccess == status_; }
+
+    cudaError_t __host__ __device__
+    status() const { return status_; }
+
+    __host__ __device__ T const &
+    value() const { return value_; }
+
+    __host__ __device__ operator T const &() const { return value_; }
+  };
+
+  THRUST_RUNTIME_FUNCTION
+  inline int get_ptx_version()
+  {
+    int ptx_version = 0;
+    if (cub::PtxVersion(ptx_version) != cudaSuccess) 
+    {
+      // Failure might mean that there's no device found
+      const int current_device = cub::CurrentDevice();
+      if (current_device < 0)
+      {
+        cuda_cub::throw_on_error(cudaErrorNoDevice, "No GPU is available\n");
+      }
+
+      // Any subsequent failure means the provided device binary does not match 
+      // the generated function code
+      int major = 0, minor = 0;
+      cudaError_t attr_status;
+
+      attr_status = cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, current_device);
+      cuda_cub::throw_on_error(attr_status,
+                              "get_ptx_version :"
+                              "failed to get major CUDA device compute capability version.");
+
+      attr_status = cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, current_device);
+      cuda_cub::throw_on_error(attr_status,
+                              "get_ptx_version :"
+                              "failed to get minor CUDA device compute capability version.");
+        
+      // Index from which SM code has to start in the message below
+      int code_offset = 37;
+      char str[] = "This program was not compiled for SM     \n";
+
+      auto print_1_helper = [&](int v) {
+        str[code_offset] = static_cast<char>(v) + '0';
+        code_offset++;
+      };
+
+      // Assume two digits will be enough
+      auto print_2_helper = [&](int v) {
+        if (v / 10 != 0) {
+          print_1_helper(v / 10);
+        }
+        print_1_helper(v % 10);
+      };
+
+      print_2_helper(major);
+      print_2_helper(minor);
+
+      cuda_cub::throw_on_error(cudaErrorInvalidDevice, str);
+    }
+
+    return ptx_version;
+  }
+
+  THRUST_RUNTIME_FUNCTION
+  inline cudaError_t sync_stream(cudaStream_t stream)
+  {
+    return cub::SyncStream(stream);
+  }
+
+  inline void __device__ sync_threadblock()
+  {
+    cub::CTA_SYNC();
+  }
+
+#define CUDA_CUB_RET_IF_FAIL(e) \
+  {                             \
+    auto const error = (e);     \
+    if (cub::Debug(error, __FILE__, __LINE__)) return error; \
+  }
+
+  // uninitialized
+  // -------
+  // stores type in uninitialized form
+  //
+  template <class T>
+  struct uninitialized
+  {
+    typedef typename cub::UnitWord<T>::DeviceWord DeviceWord;
+
+    enum
+    {
+      WORDS = sizeof(T) / sizeof(DeviceWord)
+    };
+
+    DeviceWord storage[WORDS];
+
+    __host__ __device__ __forceinline__ T& get()
+    {
+      return reinterpret_cast<T&>(*this);
+    }
+
+    __host__ __device__ __forceinline__ operator T&() { return get(); }
+  };
+
+  // uninitialized_array
+  // --------------
+  // allocates uninitialized data on stack
+  template<class T, size_t N>
+  struct array
+  {
+    typedef T value_type;
+    typedef T ref[N];
+    enum {SIZE = N};
+    private:
+      T data_[N];
+
+    public:
+      __host__ __device__ T* data() { return data_; }
+      __host__ __device__ const T* data() const { return data_; }
+      __host__ __device__ T& operator[](unsigned int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](unsigned int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ unsigned int size() const { return N; }
+      __host__ __device__ operator ref&() { return data_; }
+  };
+
+
+  // uninitialized_array
+  // --------------
+  // allocates uninitialized data on stack
+  template<class T, size_t N>
+  struct uninitialized_array
+  {
+    typedef T value_type;
+    typedef T ref[N];
+    enum {SIZE = N};
+    private:
+      char data_[N * sizeof(T)];
+
+    public:
+      __host__ __device__ T* data() { return data_; }
+      __host__ __device__ const T* data() const { return data_; }
+      __host__ __device__ T& operator[](unsigned int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](unsigned int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ T& operator[](int idx) { return ((T*)data_)[idx]; }
+      __host__ __device__ T const& operator[](int idx) const { return ((T*)data_)[idx]; }
+      __host__ __device__ unsigned int size() const { return N; }
+      __host__ __device__ operator ref&() { return *reinterpret_cast<ref*>(data_); }
+      __host__ __device__ ref& get_ref() { return (ref&)*this; }
+  };
+
+  __host__ __device__ __forceinline__ size_t align_to(size_t n, size_t align)
+  {
+    return ((n+align-1)/align) * align;
+  }
+
+  namespace host {
+    inline cuda_optional<size_t> get_max_shared_memory_per_block()
+    {
+      cudaError_t status = cudaSuccess;
+      int         dev_id = 0;
+      status             = cudaGetDevice(&dev_id);
+      if (status != cudaSuccess) return cuda_optional<size_t>(0, status);
+
+      int max_shmem = 0;
+      status        = cudaDeviceGetAttribute(&max_shmem,
+                                      cudaDevAttrMaxSharedMemoryPerBlock,
+                                      dev_id);
+      if (status != cudaSuccess) return cuda_optional<size_t>(0, status);
+      return cuda_optional<size_t>(max_shmem, status);
+    }
+  }
+
+  template <int           ALLOCATIONS>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  alias_storage(void*   storage_ptr,
+                size_t& storage_size,
+                void* (&allocations)[ALLOCATIONS],
+                size_t (&allocation_sizes)[ALLOCATIONS])
+  {
+    return cub::AliasTemporaries(storage_ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+  }
+
+
+}    // namespace core
+using core::sm60;
+using core::sm52;
+using core::sm35;
+using core::sm30;
+} // namespace cuda_
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/count.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..b624f39dcca58d14f479a8004e752a490cfb0739
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/count.h
@@ -0,0 +1,80 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class UnaryPred>
+typename iterator_traits<InputIt>::difference_type __host__ __device__
+count_if(execution_policy<Derived> &policy,
+         InputIt                    first,
+         InputIt                    last,
+         UnaryPred                  unary_pred)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  typedef transform_input_iterator_t<size_type,
+                                     InputIt,
+                                     UnaryPred>
+      flag_iterator_t;
+
+  return cuda_cub::reduce_n(policy,
+                            flag_iterator_t(first, unary_pred),
+                            thrust::distance(first, last),
+                            size_type(0),
+                            plus<size_type>());
+}
+
+template <class Derived,
+          class InputIt,
+          class Value>
+typename iterator_traits<InputIt>::difference_type __host__ __device__
+count(execution_policy<Derived> &policy,
+      InputIt                    first,
+      InputIt                    last,
+      Value const &              value)
+{
+  return cuda_cub::count_if(policy,
+                            first,
+                            last,
+                            thrust::detail::equal_to_value<Value>(value));
+}
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cross_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cross_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..039531d282143ee33213a7158143a7467c2bf10e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/cross_system.h
@@ -0,0 +1,339 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+  template <class Sys1, class Sys2>
+  struct cross_system : execution_policy<cross_system<Sys1, Sys2> >
+  {
+    typedef thrust::execution_policy<Sys1> policy1;
+    typedef thrust::execution_policy<Sys2> policy2;
+
+    policy1 &sys1;
+    policy2 &sys2;
+
+    inline __host__ __device__
+    cross_system(policy1 &sys1, policy2 &sys2) : sys1(sys1), sys2(sys2) {}
+
+    inline __host__ __device__
+    cross_system<Sys2, Sys1> rotate() const
+    {
+      return cross_system<Sys2, Sys1>(sys2, sys1);
+    }
+  };
+
+#if THRUST_CPP_DIALECT >= 2011
+  // Device to host.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::system::cuda::execution_policy<Sys1> const&
+  , thrust::cpp::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToHost
+    >{}
+  )
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::cpp::execution_policy<Sys1> const&
+  , thrust::system::cuda::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyHostToDevice
+    >{}
+  )
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    thrust::system::cuda::execution_policy<Sys1> const&
+  , thrust::system::cuda::execution_policy<Sys2> const&
+  )
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToDevice
+    >{}
+  )
+
+  // Device to device.
+  template <class DerivedPolicy>
+  constexpr __host__ __device__
+  auto direction_of_copy(execution_policy<DerivedPolicy> const &)
+  THRUST_DECLTYPE_RETURNS(
+    thrust::detail::integral_constant<
+      cudaMemcpyKind, cudaMemcpyDeviceToDevice
+    >{}
+  )
+
+  template <class Sys1, class Sys2>
+  constexpr __host__ __device__
+  auto direction_of_copy(
+    execution_policy<cross_system<Sys1, Sys2>> const &systems
+  )
+  THRUST_DECLTYPE_RETURNS(
+    direction_of_copy(
+      derived_cast(derived_cast(systems).sys1)
+    , derived_cast(derived_cast(systems).sys2)
+    )
+  )
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToHost == Direction::value
+  >
+  is_device_to_host_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToHost == Direction::value
+  >
+  is_device_to_host_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyHostToDevice == Direction::value
+  >
+  is_host_to_device_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyHostToDevice == Direction::value
+  >
+  is_host_to_device_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy0,
+            typename ExecutionPolicy1,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy0>(),
+                                         std::declval<ExecutionPolicy1>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToDevice == Direction::value
+  >
+  is_device_to_device_copy(
+    ExecutionPolicy0 const& exec0
+  , ExecutionPolicy1 const& exec1
+  ) noexcept
+  {
+    return {};
+  }
+
+  template <typename ExecutionPolicy,
+            // MSVC2015 WAR: put decltype here instead of in trailing return type
+            typename Direction =
+              decltype(direction_of_copy(std::declval<ExecutionPolicy>()))>
+  constexpr __host__ __device__
+  thrust::detail::integral_constant<
+    bool, cudaMemcpyDeviceToDevice == Direction::value
+  >
+  is_device_to_device_copy(ExecutionPolicy const& exec) noexcept
+  {
+    return {};
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> &sys1,
+                       thrust::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> const &sys1,
+                       thrust::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::execution_policy<Sys1> &,
+                       thrust::cuda::execution_policy<Sys2> &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::execution_policy<Sys1> const &,
+                       thrust::cuda::execution_policy<Sys2> const &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> &sys1,
+                       thrust::cuda::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_device_system(thrust::cuda::execution_policy<Sys1> const &sys1,
+                       thrust::cuda::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::cuda::execution_policy<Sys1> &,
+                     thrust::execution_policy<Sys2> &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::cuda::execution_policy<Sys1> const &,
+                     thrust::execution_policy<Sys2> const &sys2)
+  THRUST_DECLTYPE_RETURNS(sys2)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> &sys1,
+                     thrust::cuda::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> const &sys1,
+                     thrust::cuda::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> &sys1,
+                     thrust::execution_policy<Sys2> &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+
+  // Device to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  auto
+  select_host_system(thrust::execution_policy<Sys1> const &sys1,
+                     thrust::execution_policy<Sys2> const &)
+  THRUST_DECLTYPE_RETURNS(sys1)
+#endif
+
+  // Device to host.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  cross_system<Sys1, Sys2>
+  select_system(execution_policy<Sys1> const &             sys1,
+                thrust::cpp::execution_policy<Sys2> const &sys2)
+  {
+    thrust::execution_policy<Sys1> &     non_const_sys1 = const_cast<execution_policy<Sys1> &>(sys1);
+    thrust::cpp::execution_policy<Sys2> &non_const_sys2 = const_cast<thrust::cpp::execution_policy<Sys2> &>(sys2);
+    return cross_system<Sys1, Sys2>(non_const_sys1, non_const_sys2);
+  }
+
+  // Host to device.
+  template <class Sys1, class Sys2>
+  __host__ __device__
+  cross_system<Sys1, Sys2>
+  select_system(thrust::cpp::execution_policy<Sys1> const &sys1,
+                execution_policy<Sys2> const &             sys2)
+  {
+    thrust::cpp::execution_policy<Sys1> &non_const_sys1 = const_cast<thrust::cpp::execution_policy<Sys1> &>(sys1);
+    thrust::execution_policy<Sys2> &     non_const_sys2 = const_cast<execution_policy<Sys2> &>(sys2);
+    return cross_system<Sys1, Sys2>(non_const_sys1, non_const_sys2);
+  }
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/dispatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/dispatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0e3f94ec822ade9106857d84caca9ad4680e040
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/dispatch.h
@@ -0,0 +1,79 @@
+/*
+ *  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/cstdint.h>
+#include <thrust/detail/preprocessor.h>
+#include <thrust/detail/integer_traits.h>
+
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version assumes that callables for both branches consist
+ * of the same tokens, and is intended to be used with Thrust-style dispatch
+ * interfaces, that always deduce the size type from the arguments.
+ */
+#define THRUST_INDEX_TYPE_DISPATCH(status, call, count, arguments) \
+    if (count <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int32_t>(count); \
+        status = call arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int64_t>(count); \
+        status = call arguments; \
+    }
+
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version assumes that callables for both branches consist
+ * of the same tokens, and is intended to be used with Thrust-style dispatch
+ * interfaces, that always deduce the size type from the arguments.
+ *
+ * This version of the macro supports providing two count variables, which is
+ * necessary for set algorithms.
+ */
+#define THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, call, count1, count2, arguments) \
+    if (count1 + count2 <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count1, _fixed) = static_cast<thrust::detail::int32_t>(count1); \
+        auto THRUST_PP_CAT2(count2, _fixed) = static_cast<thrust::detail::int32_t>(count2); \
+        status = call arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count1, _fixed) = static_cast<thrust::detail::int64_t>(count1); \
+        auto THRUST_PP_CAT2(count2, _fixed) = static_cast<thrust::detail::int64_t>(count2); \
+        status = call arguments; \
+    }
+/**
+ * Dispatch between 32-bit and 64-bit index based versions of the same algorithm
+ * implementation. This version allows using different token sequences for callables
+ * in both branches, and is intended to be used with CUB-style dispatch interfaces,
+ * where the "simple" interface always forces the size to be `int` (making it harder
+ * for us to use), but the complex interface that we end up using doesn't actually
+ * provide a way to fully deduce the type from just the call, making the size type
+ * appear in the token sequence of the callable.
+ *
+ * See reduce_n_impl to see an example of how this is meant to be used.
+ */
+#define THRUST_INDEX_TYPE_DISPATCH2(status, call_32, call_64, count, arguments) \
+    if (count <= thrust::detail::integer_traits<thrust::detail::int32_t>::const_max) { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int32_t>(count); \
+        status = call_32 arguments; \
+    } \
+    else { \
+        auto THRUST_PP_CAT2(count, _fixed) = static_cast<thrust::detail::int64_t>(count); \
+        status = call_64 arguments; \
+    }
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/equal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/equal.h
new file mode 100644
index 0000000000000000000000000000000000000000..aec608245261227c2ab0df2d05e19f80404d4a69
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/equal.h
@@ -0,0 +1,74 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/mismatch.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class BinaryPred>
+bool __host__ __device__
+equal(execution_policy<Derived>& policy,
+      InputIt1                   first1,
+      InputIt1                   last1,
+      InputIt2                   first2,
+      BinaryPred                 binary_pred)
+{
+  return cuda_cub::mismatch(policy, first1, last1, first2, binary_pred).first == last1;
+}
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2>
+bool __host__ __device__
+equal(execution_policy<Derived>& policy,
+      InputIt1                   first1,
+      InputIt1                   last1,
+      InputIt2                   first2)
+{
+  typedef typename thrust::iterator_value<InputIt1>::type InputType1;
+  return cuda_cub::equal(policy,
+                         first1,
+                         last1,
+                         first2,
+                         equal_to<InputType1>());
+}
+
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/error.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/error.inl
new file mode 100644
index 0000000000000000000000000000000000000000..e523052113131ac4c666143b4eecfeb981ef8dfd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/error.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>
+
+#include <thrust/system/cuda/error.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+
+error_code make_error_code(cuda::errc::errc_t e)
+{
+  return error_code(static_cast<int>(e), cuda_category());
+} // end make_error_code()
+
+
+error_condition make_error_condition(cuda::errc::errc_t e)
+{
+  return error_condition(static_cast<int>(e), cuda_category());
+} // end make_error_condition()
+
+
+namespace cuda_cub
+{
+
+namespace detail
+{
+
+
+class cuda_error_category
+  : public error_category
+{
+  public:
+    inline cuda_error_category(void) {}
+
+    inline virtual const char *name(void) const
+    {
+      return "cuda";
+    }
+
+    inline virtual std::string message(int ev) const
+    {
+      char const* const unknown_str  = "unknown error";
+      char const* const unknown_name = "cudaErrorUnknown";
+      char const* c_str  = ::cudaGetErrorString(static_cast<cudaError_t>(ev));
+      char const* c_name = ::cudaGetErrorName(static_cast<cudaError_t>(ev));
+      return std::string(c_name ? c_name : unknown_name)
+           + ": " + (c_str ? c_str : unknown_str);
+    }
+
+    inline virtual error_condition default_error_condition(int ev) const
+    {
+      using namespace cuda::errc;
+
+      if(ev < ::cudaErrorUnknown)
+      {
+        return make_error_condition(static_cast<errc_t>(ev));
+      }
+
+      return system_category().default_error_condition(ev);
+    }
+}; // end cuda_error_category
+
+} // end detail
+
+} // end namespace cuda_cub
+
+
+const error_category &cuda_category(void)
+{
+  static const thrust::system::cuda_cub::detail::cuda_error_category result;
+  return result;
+}
+
+
+} // end namespace system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..4202424c5e4e3cd31754056a53e4e9b3db77714a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/execution_policy.h
@@ -0,0 +1,100 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/version.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/detail/allocator_aware_execution_policy.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <thrust/detail/dependencies_aware_execution_policy.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub
+{
+
+struct tag;
+
+template <class>
+struct execution_policy;
+
+template <>
+struct execution_policy<tag> : thrust::execution_policy<tag>
+{
+  typedef tag tag_type;
+};
+
+struct tag : execution_policy<tag>
+, thrust::detail::allocator_aware_execution_policy<cuda_cub::execution_policy>
+#if THRUST_CPP_DIALECT >= 2011
+, thrust::detail::dependencies_aware_execution_policy<cuda_cub::execution_policy>
+#endif
+{};
+
+template <class Derived>
+struct execution_policy : thrust::execution_policy<Derived>
+{
+  typedef tag tag_type; 
+  operator tag() const { return tag(); }
+};
+
+} // namespace cuda_cub
+
+namespace system { namespace cuda { namespace detail
+{
+
+using thrust::cuda_cub::tag;
+using thrust::cuda_cub::execution_policy;
+
+}}} // namespace system::cuda::detail
+
+namespace system { namespace cuda
+{
+
+using thrust::cuda_cub::tag;
+using thrust::cuda_cub::execution_policy;
+
+}} // namespace system::cuda
+
+namespace cuda
+{
+
+using thrust::cuda_cub::tag;
+using thrust::cuda_cub::execution_policy;
+
+} // namespace cuda
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/extrema.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/extrema.h
new file mode 100644
index 0000000000000000000000000000000000000000..4fe7ec86b5c4a8a725d7d7ff6c1f92a4f9cd3aeb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/extrema.h
@@ -0,0 +1,548 @@
+/*******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/reduce.h>
+
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __extrema {
+
+  template <class InputType, class IndexType, class Predicate>
+  struct arg_min_f
+  {
+    Predicate predicate;
+    typedef tuple<InputType, IndexType> pair_type;
+
+    __host__ __device__
+    arg_min_f(Predicate p) : predicate(p) {}
+
+    pair_type __device__
+    operator()(pair_type const &lhs, pair_type const &rhs)
+    {
+      InputType const &rhs_value = get<0>(rhs);
+      InputType const &lhs_value = get<0>(lhs);
+      IndexType const &rhs_key   = get<1>(rhs);
+      IndexType const &lhs_key   = get<1>(lhs);
+
+      // check values first
+      if (predicate(lhs_value, rhs_value))
+        return lhs;
+      else if (predicate(rhs_value, lhs_value))
+        return rhs;
+
+      // values are equivalent, prefer smaller index
+      if (lhs_key < rhs_key)
+        return lhs;
+      else
+        return rhs;
+    }
+  };    // struct arg_min_f
+
+  template <class InputType, class IndexType, class Predicate>
+  struct arg_max_f
+  {
+    Predicate predicate;
+    typedef tuple<InputType, IndexType> pair_type;
+
+    __host__ __device__
+    arg_max_f(Predicate p) : predicate(p) {}
+
+    pair_type __device__
+    operator()(pair_type const &lhs, pair_type const &rhs)
+    {
+      InputType const &rhs_value = get<0>(rhs);
+      InputType const &lhs_value = get<0>(lhs);
+      IndexType const &rhs_key   = get<1>(rhs);
+      IndexType const &lhs_key   = get<1>(lhs);
+
+      // check values first
+      if (predicate(lhs_value, rhs_value))
+        return rhs;
+      else if (predicate(rhs_value, lhs_value))
+        return lhs;
+
+      // values are equivalent, prefer smaller index
+      if (lhs_key < rhs_key)
+        return lhs;
+      else
+        return rhs;
+    }
+  };    // struct arg_max_f
+
+  template<class InputType, class IndexType, class Predicate>
+  struct arg_minmax_f
+  {
+    Predicate predicate;
+
+    typedef tuple<InputType, IndexType> pair_type;
+    typedef tuple<pair_type, pair_type> two_pairs_type;
+
+    typedef arg_min_f<InputType, IndexType, Predicate> arg_min_t;
+    typedef arg_max_f<InputType, IndexType, Predicate> arg_max_t;
+
+    __host__ __device__
+    arg_minmax_f(Predicate p) : predicate(p)
+    {
+    }
+
+    two_pairs_type __device__
+    operator()(two_pairs_type const &lhs, two_pairs_type const &rhs)
+    {
+      pair_type const &rhs_min = get<0>(rhs);
+      pair_type const &lhs_min = get<0>(lhs);
+      pair_type const &rhs_max = get<1>(rhs);
+      pair_type const &lhs_max = get<1>(lhs);
+
+      auto result = thrust::make_tuple(arg_min_t(predicate)(lhs_min, rhs_min),
+                                       arg_max_t(predicate)(lhs_max, rhs_max));
+
+      return result;
+    }
+
+    struct duplicate_tuple
+    {
+      __device__ two_pairs_type
+      operator()(pair_type const &t)
+      {
+        return thrust::make_tuple(t, t);
+      }
+    };
+  }; // struct arg_minmax_f
+
+  template <class T,
+            class InputIt,
+            class OutputIt,
+            class Size,
+            class ReductionOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *       d_temp_storage,
+            size_t &     temp_storage_bytes,
+            InputIt      input_it,
+            Size         num_items,
+            ReductionOp  reduction_op,
+            OutputIt     output_it,
+            cudaStream_t stream)
+  {
+    using core::AgentPlan;
+    using core::AgentLauncher;
+    using core::get_agent_plan;
+    using core::cuda_optional;
+
+    typedef typename detail::make_unsigned_special<Size>::type UnsignedSize;
+
+    if (num_items == 0)
+      return cudaErrorNotSupported;
+
+    typedef AgentLauncher<
+        __reduce::ReduceAgent<InputIt, OutputIt, T, Size, ReductionOp> >
+        reduce_agent;
+
+    typename reduce_agent::Plan reduce_plan = reduce_agent::get_plan(stream);
+
+    cudaError_t status = cudaSuccess;
+
+
+    if (num_items <= reduce_plan.items_per_tile)
+    {
+      size_t vshmem_size = core::vshmem_size(reduce_plan.shared_memory_size, 1);
+
+      // small, single tile size
+      if (d_temp_storage == NULL)
+      {
+        temp_storage_bytes = max<size_t>(1, vshmem_size);
+        return status;
+      }
+      char *vshmem_ptr = vshmem_size > 0 ? (char*)d_temp_storage : NULL;
+
+      reduce_agent ra(reduce_plan, num_items, stream, vshmem_ptr, "reduce_agent: single_tile only");
+      ra.launch(input_it, output_it, num_items, reduction_op);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    }
+    else
+    {
+      // regular size
+      cuda_optional<int> sm_count = core::get_sm_count();
+      CUDA_CUB_RET_IF_FAIL(sm_count.status());
+
+      // reduction will not use more cta counts than requested
+      cuda_optional<int> max_blocks_per_sm =
+          reduce_agent::
+              template get_max_blocks_per_sm<InputIt,
+                                             OutputIt,
+                                             Size,
+                                             cub::GridEvenShare<Size>,
+                                             cub::GridQueue<UnsignedSize>,
+                                             ReductionOp>(reduce_plan);
+      CUDA_CUB_RET_IF_FAIL(max_blocks_per_sm.status());
+
+
+
+      int reduce_device_occupancy = (int)max_blocks_per_sm * sm_count;
+
+      int sm_oversubscription = 5;
+      int max_blocks          = reduce_device_occupancy * sm_oversubscription;
+
+      cub::GridEvenShare<Size> even_share;
+      even_share.DispatchInit(num_items, max_blocks,
+                              reduce_plan.items_per_tile);
+
+      // we will launch at most "max_blocks" blocks in a grid
+      // so preallocate virtual shared memory storage for this if required
+      //
+      size_t vshmem_size = core::vshmem_size(reduce_plan.shared_memory_size,
+                                             max_blocks);
+
+      // Temporary storage allocation requirements
+      void * allocations[3] = {NULL, NULL, NULL};
+      size_t allocation_sizes[3] =
+          {
+              max_blocks * sizeof(T),                            // bytes needed for privatized block reductions
+              cub::GridQueue<UnsignedSize>::AllocationSize(),    // bytes needed for grid queue descriptor0
+              vshmem_size                                        // size of virtualized shared memory storage
+          };
+      status = cub::AliasTemporaries(d_temp_storage,
+                                     temp_storage_bytes,
+                                     allocations,
+                                     allocation_sizes);
+      CUDA_CUB_RET_IF_FAIL(status);
+      if (d_temp_storage == NULL)
+      {
+        return status;
+      }
+
+      T *d_block_reductions = (T*) allocations[0];
+      cub::GridQueue<UnsignedSize> queue(allocations[1]);
+      char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[2] : NULL;
+
+
+      // Get grid size for device_reduce_sweep_kernel
+      int reduce_grid_size = 0;
+      if (reduce_plan.grid_mapping == cub::GRID_MAPPING_RAKE)
+      {
+        // Work is distributed evenly
+        reduce_grid_size = even_share.grid_size;
+      }
+      else if (reduce_plan.grid_mapping == cub::GRID_MAPPING_DYNAMIC)
+      {
+        // Work is distributed dynamically
+        size_t num_tiles = cub::DivideAndRoundUp(num_items, reduce_plan.items_per_tile);
+
+        // if not enough to fill the device with threadblocks
+        // then fill the device with threadblocks
+        reduce_grid_size = static_cast<int>((min)(num_tiles, static_cast<size_t>(reduce_device_occupancy)));
+
+        typedef AgentLauncher<__reduce::DrainAgent<Size> > drain_agent;
+        AgentPlan drain_plan = drain_agent::get_plan();
+        drain_plan.grid_size = 1;
+        drain_agent da(drain_plan, stream, "__reduce::drain_agent");
+        da.launch(queue, num_items);
+        CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+      }
+      else
+      {
+        CUDA_CUB_RET_IF_FAIL(cudaErrorNotSupported);
+      }
+
+      reduce_plan.grid_size = reduce_grid_size;
+      reduce_agent ra(reduce_plan, stream, vshmem_ptr, "reduce_agent: regular size reduce");
+      ra.launch(input_it,
+                d_block_reductions,
+                num_items,
+                even_share,
+                queue,
+                reduction_op);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+
+      typedef AgentLauncher<
+        __reduce::ReduceAgent<T*, OutputIt, T, Size, ReductionOp> >
+        reduce_agent_single;
+
+      reduce_plan.grid_size = 1;
+      reduce_agent_single ra1(reduce_plan, stream, vshmem_ptr, "reduce_agent: single tile reduce");
+
+      ra1.launch(d_block_reductions, output_it, reduce_grid_size, reduction_op);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    }
+
+    return status;
+  }    // func doit_step
+
+  // this is an init-less reduce, needed for min/max-element functionality
+  // this will avoid copying the first value from device->host
+  template <typename Derived,
+            typename InputIt,
+            typename Size,
+            typename BinaryOp,
+            typename T>
+  THRUST_RUNTIME_FUNCTION
+  T extrema(execution_policy<Derived>& policy,
+            InputIt                    first,
+            Size                       num_items,
+            BinaryOp                   binary_op,
+            T*)
+  {
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    THRUST_INDEX_TYPE_DISPATCH(status, doit_step<T>, num_items,
+        (NULL, temp_storage_bytes, first, num_items_fixed,
+            binary_op, reinterpret_cast<T*>(NULL), stream));
+    cuda_cub::throw_on_error(status, "extrema failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(T*), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "extrema failed on 1st alias storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "extrema failed on 2nd alias storage");
+
+    T* d_result = thrust::detail::aligned_reinterpret_cast<T*>(allocations[0]);
+
+    THRUST_INDEX_TYPE_DISPATCH(status, doit_step<T>, num_items,
+        (allocations[1], temp_storage_bytes, first,
+            num_items_fixed, binary_op, d_result, stream));
+    cuda_cub::throw_on_error(status, "extrema failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "extrema failed to synchronize");
+
+    T result = cuda_cub::get_value(policy, d_result);
+
+    return result;
+  }
+
+  template <template <class, class, class> class ArgFunctor,
+            class Derived,
+            class ItemsIt,
+            class BinaryPred>
+  ItemsIt THRUST_RUNTIME_FUNCTION
+  element(execution_policy<Derived> &policy,
+          ItemsIt                    first,
+          ItemsIt                    last,
+          BinaryPred                 binary_pred)
+  {
+    if (first == last)
+      return last;
+
+    typedef typename iterator_traits<ItemsIt>::value_type      InputType;
+    typedef typename iterator_traits<ItemsIt>::difference_type IndexType;
+
+    IndexType num_items = static_cast<IndexType>(thrust::distance(first, last));
+
+    typedef tuple<ItemsIt, counting_iterator_t<IndexType> > iterator_tuple;
+    typedef zip_iterator<iterator_tuple> zip_iterator;
+
+    iterator_tuple iter_tuple = thrust::make_tuple(first, counting_iterator_t<IndexType>(0));
+
+
+    typedef ArgFunctor<InputType, IndexType, BinaryPred> arg_min_t;
+    typedef tuple<InputType, IndexType> T;
+
+    zip_iterator begin = make_zip_iterator(iter_tuple);
+
+    T result = extrema(policy,
+                       begin,
+                       num_items,
+                       arg_min_t(binary_pred),
+                       (T *)(NULL));
+    return first + thrust::get<1>(result);
+  }
+
+
+}    // namespace __extrema
+
+/// min element
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt,
+          class BinaryPred>
+ItemsIt __host__ __device__
+min_element(execution_policy<Derived> &policy,
+            ItemsIt                    first,
+            ItemsIt                    last,
+            BinaryPred                 binary_pred)
+{
+  THRUST_CDP_DISPATCH(
+    (last = __extrema::element<__extrema::arg_min_f>(policy,
+                                                     first,
+                                                     last,
+                                                     binary_pred);),
+    (last = thrust::min_element(cvt_to_seq(derived_cast(policy)),
+                                first,
+                                last,
+                                binary_pred);));
+  return last;
+}
+
+template <class Derived,
+          class ItemsIt>
+ItemsIt __host__ __device__
+min_element(execution_policy<Derived> &policy,
+            ItemsIt                    first,
+            ItemsIt                    last)
+{
+  typedef typename iterator_value<ItemsIt>::type value_type;
+  return cuda_cub::min_element(policy, first, last, less<value_type>());
+}
+
+/// max element
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt,
+          class BinaryPred>
+ItemsIt __host__ __device__
+max_element(execution_policy<Derived> &policy,
+            ItemsIt                    first,
+            ItemsIt                    last,
+            BinaryPred                 binary_pred)
+{
+  THRUST_CDP_DISPATCH(
+    (last = __extrema::element<__extrema::arg_max_f>(policy,
+                                                     first,
+                                                     last,
+                                                     binary_pred);),
+    (last = thrust::max_element(cvt_to_seq(derived_cast(policy)),
+                                first,
+                                last,
+                                binary_pred);));
+  return last;
+}
+
+template <class Derived,
+          class ItemsIt>
+ItemsIt __host__ __device__
+max_element(execution_policy<Derived> &policy,
+            ItemsIt                    first,
+            ItemsIt                    last)
+{
+  typedef typename iterator_value<ItemsIt>::type value_type;
+  return cuda_cub::max_element(policy, first, last, less<value_type>());
+}
+
+/// minmax element
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt,
+          class BinaryPred>
+pair<ItemsIt, ItemsIt> __host__ __device__
+minmax_element(execution_policy<Derived> &policy,
+               ItemsIt                    first,
+               ItemsIt                    last,
+               BinaryPred                 binary_pred)
+{
+  auto ret = thrust::make_pair(last, last);
+  if (first == last)
+  {
+    return ret;
+  }
+
+  THRUST_CDP_DISPATCH(
+    (using InputType = typename iterator_traits<ItemsIt>::value_type;
+     using IndexType = typename iterator_traits<ItemsIt>::difference_type;
+
+     const auto num_items =
+       static_cast<IndexType>(thrust::distance(first, last));
+
+     using iterator_tuple = tuple<ItemsIt, counting_iterator_t<IndexType>>;
+     using zip_iterator   = zip_iterator<iterator_tuple>;
+
+     iterator_tuple iter_tuple =
+       thrust::make_tuple(first, counting_iterator_t<IndexType>(0));
+
+     using arg_minmax_t =
+       __extrema::arg_minmax_f<InputType, IndexType, BinaryPred>;
+     using two_pairs_type = typename arg_minmax_t::two_pairs_type;
+     using duplicate_t    = typename arg_minmax_t::duplicate_tuple;
+     using transform_t =
+       transform_input_iterator_t<two_pairs_type, zip_iterator, duplicate_t>;
+
+     zip_iterator   begin = make_zip_iterator(iter_tuple);
+     two_pairs_type result =
+       __extrema::extrema(policy,
+                          transform_t(begin, duplicate_t()),
+                          num_items,
+                          arg_minmax_t(binary_pred),
+                          (two_pairs_type *)(NULL));
+     ret = thrust::make_pair(first + get<1>(get<0>(result)),
+                             first + get<1>(get<1>(result)));),
+    // CDP Sequential impl:
+    (ret = thrust::minmax_element(cvt_to_seq(derived_cast(policy)),
+                                  first,
+                                  last,
+                                  binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class ItemsIt>
+pair<ItemsIt, ItemsIt> __host__ __device__
+minmax_element(execution_policy<Derived> &policy,
+               ItemsIt                    first,
+               ItemsIt                    last)
+{
+  typedef typename iterator_value<ItemsIt>::type value_type;
+  return cuda_cub::minmax_element(policy, first, last, less<value_type>());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..80ea68592a2f719a3aa10dfab4e24c4e0617e944
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/fill.h
@@ -0,0 +1,90 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __fill {
+
+  // fill functor
+  template<class Iterator, class T>
+  struct functor
+  {
+    Iterator it;
+    T value;
+
+    THRUST_FUNCTION
+    functor(Iterator it, T value)
+        : it(it), value(value) {}
+
+    template<class Size>
+    THRUST_DEVICE_FUNCTION void operator()(Size idx)
+    {
+      it[idx] = value;
+    }
+  }; // struct functor
+
+}    // namespace __fill
+
+template <class Derived, class OutputIterator, class Size, class T>
+OutputIterator __host__ __device__
+fill_n(execution_policy<Derived>& policy,
+       OutputIterator             first,
+       Size                       count,
+       const T&                   value)
+{
+  cuda_cub::parallel_for(policy,
+                         __fill::functor<OutputIterator, T>(
+                         first,
+                         value),
+                         count);
+
+  return first + count;
+}    // func fill_n
+
+template <class Derived, class ForwardIterator, class T>
+void __host__ __device__
+fill(execution_policy<Derived>& policy,
+     ForwardIterator            first,
+     ForwardIterator            last,
+     const T&                   value)
+{
+  cuda_cub::fill_n(policy, first, thrust::distance(first,last), value);
+} // func filll
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/find.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/find.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7d2b748f870c69eb8e44b8c3d6d5068ac06683d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/find.h
@@ -0,0 +1,218 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+// XXX forward declare to circumvent circular depedency
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+find_if(execution_policy<Derived>& policy,
+        InputIt                    first,
+        InputIt                    last,
+        Predicate                  predicate);
+
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+find_if_not(execution_policy<Derived>& policy,
+            InputIt                    first,
+            InputIt                    last,
+            Predicate                  predicate);
+
+template <class Derived,
+          class InputIt,
+          class T>
+InputIt __host__ __device__
+find(execution_policy<Derived> &policy,
+     InputIt                    first,
+     InputIt                    last,
+     T const& value);
+
+}; // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/iterator/zip_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __find_if {
+
+  template <typename TupleType>
+  struct functor
+  {
+    THRUST_DEVICE_FUNCTION TupleType
+    operator()(const TupleType& lhs, const TupleType& rhs) const
+    {
+      // select the smallest index among true results
+      if (thrust::get<0>(lhs) && thrust::get<0>(rhs))
+      {
+        return TupleType(true, (thrust::min)(thrust::get<1>(lhs), thrust::get<1>(rhs)));
+      }
+      else if (thrust::get<0>(lhs))
+      {
+        return lhs;
+      }
+      else
+      {
+        return rhs;
+      }
+    }
+  };
+}    // namespace __find_if
+
+template <class Derived,
+          class InputIt,
+          class Size,
+          class Predicate>
+InputIt __host__ __device__
+find_if_n(execution_policy<Derived>& policy,
+          InputIt                    first,
+          Size                       num_items,
+          Predicate                  predicate)
+{
+  typedef typename thrust::tuple<bool,Size> result_type;
+  
+  // empty sequence
+  if(num_items == 0) return first;
+  
+  // this implementation breaks up the sequence into separate intervals
+  // in an attempt to early-out as soon as a value is found
+  //
+  // XXX compose find_if from a look-back prefix scan algorithm
+  //     and abort kernel when the first element is found
+
+
+  // TODO incorporate sizeof(InputType) into interval_threshold and round to multiple of 32
+  const Size interval_threshold = 1 << 20;
+  const Size interval_size = (thrust::min)(interval_threshold, num_items);
+  
+  // force transform_iterator output to bool
+  typedef transform_input_iterator_t<bool,
+                                     InputIt,
+                                     Predicate>
+      XfrmIterator;
+  typedef thrust::tuple<XfrmIterator,
+                        counting_iterator_t<Size> >
+      IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
+
+  IteratorTuple iter_tuple =
+      thrust::make_tuple(XfrmIterator(first, predicate),
+                         counting_iterator_t<Size>(0));
+
+  ZipIterator begin = thrust::make_zip_iterator(iter_tuple);
+  ZipIterator end   = begin + num_items;
+
+  for (ZipIterator interval_begin = begin;
+       interval_begin < end;
+       interval_begin += interval_size)
+  {
+    ZipIterator interval_end = interval_begin + interval_size;
+    if(end < interval_end)
+    {
+      interval_end = end;
+    } // end if
+
+    result_type result = reduce(policy,
+                                interval_begin,
+                                interval_end,
+                                result_type(false, interval_end - begin),
+                                __find_if::functor<result_type>());
+
+    // see if we found something
+    if(thrust::get<0>(result))
+    {
+      return first + thrust::get<1>(result);
+    }
+  }
+  
+  //nothing was found if we reach here...
+  return first + num_items;
+}
+
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+find_if(execution_policy<Derived>& policy,
+        InputIt                    first,
+        InputIt                    last,
+        Predicate                  predicate)
+{
+  return cuda_cub::find_if_n(policy, first, thrust::distance(first,last), predicate);
+}
+
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+find_if_not(execution_policy<Derived>& policy,
+            InputIt                    first,
+            InputIt                    last,
+            Predicate                  predicate)
+{
+  return cuda_cub::find_if(policy, first, last, thrust::detail::not1(predicate));
+}
+
+
+template <class Derived,
+          class InputIt,
+          class T>
+InputIt __host__ __device__
+find(execution_policy<Derived> &policy,
+     InputIt                    first,
+     InputIt                    last,
+     T const& value)
+{
+  using thrust::placeholders::_1;
+
+  return cuda_cub::find_if(policy,
+                        first,
+                        last,
+                        _1 == value);
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..518538ff362ae7a7f41c14b0de039b0bbd06e7d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/for_each.h
@@ -0,0 +1,104 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/detail/function.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+  // for_each functor
+  template <class Input, class UnaryOp>
+  struct for_each_f
+  {
+    Input input;
+    UnaryOp op;
+
+    THRUST_FUNCTION
+    for_each_f(Input input, UnaryOp op)
+        : input(input), op(op) {}
+
+    template <class Size>
+    THRUST_DEVICE_FUNCTION void operator()(Size idx)
+    {
+      op(raw_reference_cast(*(input + idx)));
+    }
+  };
+
+  //-------------------------
+  // Thrust API entry points
+  //-------------------------
+
+  // for_each_n
+  template <class Derived,
+            class Input,
+            class Size,
+            class UnaryOp>
+  Input THRUST_FUNCTION
+  for_each_n(execution_policy<Derived> &policy,
+             Input                      first,
+             Size                       count,
+             UnaryOp                    op)
+  {
+    typedef thrust::detail::wrapped_function<UnaryOp, void> wrapped_t;
+    wrapped_t wrapped_op(op);
+
+    cuda_cub::parallel_for(policy,
+                           for_each_f<Input, wrapped_t>(first, wrapped_op),
+                           count);
+
+    return first + count;
+  }
+
+  // for_each
+  template <class Derived,
+            class Input,
+            class UnaryOp>
+  Input THRUST_FUNCTION
+  for_each(execution_policy<Derived> &policy,
+           Input                      first,
+           Input                      last,
+           UnaryOp                    op)
+  {
+    typedef typename iterator_traits<Input>::difference_type size_type;
+    size_type count = static_cast<size_type>(thrust::distance(first,last));
+    return cuda_cub::for_each_n(policy, first,  count, op);
+  }
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/future.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/future.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f23184aae9d52697740daee9f60a8b00c7c7ef08
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/future.inl
@@ -0,0 +1,1372 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+// TODO: Split into more granular headers (move unique_stream/unique_marker to
+// another header, etc).
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/optional.h>
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/integer_sequence.h>
+#include <thrust/type_traits/remove_cvref.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/tuple_algorithms.h>
+#include <thrust/allocate_unique.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/execute_with_dependencies.h>
+#include <thrust/detail/event_error.h>
+#include <thrust/system/cuda/memory.h>
+#include <thrust/system/cuda/future.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/get_value.h>
+
+#include <type_traits>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// Forward declaration.
+struct new_stream_t;
+
+namespace system { namespace cuda { namespace detail
+{
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct nonowning_t final {};
+
+THRUST_INLINE_CONSTANT nonowning_t nonowning{};
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct marker_deleter final
+{
+  __host__
+  void operator()(CUevent_st* e) const
+  {
+    if (nullptr != e)
+      thrust::cuda_cub::throw_on_error(cudaEventDestroy(e));
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct unique_marker final
+{
+  using native_handle_type = CUevent_st*;
+
+private:
+  std::unique_ptr<CUevent_st, marker_deleter> handle_;
+
+public:
+  /// \brief Create a new stream and construct a handle to it. When the handle
+  ///        is destroyed, the stream is destroyed.
+  __host__
+  unique_marker()
+    : handle_(nullptr, marker_deleter())
+  {
+    native_handle_type e;
+    thrust::cuda_cub::throw_on_error(
+      cudaEventCreateWithFlags(&e, cudaEventDisableTiming)
+    );
+    handle_.reset(e);
+  }
+
+  __thrust_exec_check_disable__
+  unique_marker(unique_marker const&) = delete;
+  __thrust_exec_check_disable__
+  unique_marker(unique_marker&&) = default;
+  __thrust_exec_check_disable__
+  unique_marker& operator=(unique_marker const&) = delete;
+  __thrust_exec_check_disable__
+  unique_marker& operator=(unique_marker&&) = default;
+
+  __thrust_exec_check_disable__
+  ~unique_marker() = default;
+
+  __host__
+  auto get() const
+  THRUST_DECLTYPE_RETURNS(native_handle_type(handle_.get()));
+  __host__
+  auto native_handle() const
+  THRUST_DECLTYPE_RETURNS(native_handle_type(handle_.get()));
+
+  __host__
+  bool valid() const noexcept { return bool(handle_); }
+
+  __host__
+  bool ready() const
+  {
+    cudaError_t const err = cudaEventQuery(handle_.get());
+
+    if (cudaErrorNotReady == err)
+      return false;
+
+    // Throw on any other error.
+    thrust::cuda_cub::throw_on_error(err);
+
+    return true;
+  }
+
+  __host__
+  void wait() const
+  {
+    thrust::cuda_cub::throw_on_error(cudaEventSynchronize(handle_.get()));
+  }
+
+  __host__
+  bool operator==(unique_marker const& other) const
+  {
+    return other.handle_ == handle_;
+  }
+
+  __host__
+  bool operator!=(unique_marker const& other) const
+  {
+    return !(other == *this);
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct stream_deleter final
+{
+  __host__
+  void operator()(CUstream_st* s) const
+  {
+    if (nullptr != s)
+      thrust::cuda_cub::throw_on_error(cudaStreamDestroy(s));
+  }
+};
+
+struct stream_conditional_deleter final
+{
+private:
+  bool cond_;
+
+public:
+  __host__
+  constexpr stream_conditional_deleter() noexcept
+    : cond_(true) {}
+
+  __host__
+  explicit constexpr stream_conditional_deleter(nonowning_t) noexcept
+    : cond_(false) {}
+
+  __host__
+  void operator()(CUstream_st* s) const
+  {
+    if (cond_ && nullptr != s)
+    {
+      thrust::cuda_cub::throw_on_error(cudaStreamDestroy(s));
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct unique_stream final
+{
+  using native_handle_type = CUstream_st*;
+
+private:
+  std::unique_ptr<CUstream_st, stream_conditional_deleter> handle_;
+
+public:
+  /// \brief Create a new stream and construct a handle to it. When the handle
+  ///        is destroyed, the stream is destroyed.
+  __host__
+  unique_stream()
+    : handle_(nullptr, stream_conditional_deleter())
+  {
+    native_handle_type s;
+    thrust::cuda_cub::throw_on_error(
+      cudaStreamCreateWithFlags(&s, cudaStreamNonBlocking)
+    );
+    handle_.reset(s);
+  }
+
+  /// \brief Construct a non-owning handle to an existing stream. When the
+  ///        handle is destroyed, the stream is not destroyed.
+  __host__
+  explicit unique_stream(nonowning_t, native_handle_type handle)
+    : handle_(handle, stream_conditional_deleter(nonowning))
+  {}
+
+  __thrust_exec_check_disable__
+  unique_stream(unique_stream const&) = delete;
+
+  // GCC 10 complains if this is defaulted. See NVIDIA/thrust#1269.
+  __thrust_exec_check_disable__
+  __host__ unique_stream(unique_stream &&o) noexcept
+    : handle_(std::move(o.handle_))
+  {}
+
+  __thrust_exec_check_disable__
+  unique_stream& operator=(unique_stream const&) = delete;
+  __thrust_exec_check_disable__
+  unique_stream& operator=(unique_stream&&) = default;
+
+  __thrust_exec_check_disable__
+  ~unique_stream() = default;
+
+  __host__
+  auto get() const
+  THRUST_DECLTYPE_RETURNS(native_handle_type(handle_.get()));
+  __host__
+  auto native_handle() const
+  THRUST_DECLTYPE_RETURNS(native_handle_type(handle_.get()));
+
+  __host__
+  bool valid() const noexcept { return bool(handle_); }
+
+  __host__
+  bool ready() const
+  {
+    cudaError_t const err = cudaStreamQuery(handle_.get());
+
+    if (cudaErrorNotReady == err)
+      return false;
+
+    // Throw on any other error.
+    thrust::cuda_cub::throw_on_error(err);
+
+    return true;
+  }
+
+  __host__
+  void wait() const
+  {
+    thrust::cuda_cub::throw_on_error(
+      cudaStreamSynchronize(handle_.get())
+    );
+  }
+
+  __host__
+  void depend_on(unique_marker& e)
+  {
+    thrust::cuda_cub::throw_on_error(
+      cudaStreamWaitEvent(handle_.get(), e.get(), 0)
+    );
+  }
+
+  __host__
+  void depend_on(unique_stream& s)
+  {
+    if (s != *this)
+    {
+      unique_marker e;
+      s.record(e);
+      depend_on(e);
+    }
+  }
+
+  __host__
+  void record(unique_marker& e)
+  {
+    thrust::cuda_cub::throw_on_error(cudaEventRecord(e.get(), handle_.get()));
+  }
+
+  __host__
+  bool operator==(unique_stream const& other) const
+  {
+    return other.handle_ == handle_;
+  }
+
+  __host__
+  bool operator!=(unique_stream const& other) const
+  {
+    return !(other == *this);
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+// Inheritance hierarchy of future/event shared state types.
+
+struct async_signal;
+
+template <typename KeepAlives>
+struct async_keep_alives /* : virtual async_signal */;
+
+template <typename T>
+struct async_value /* : virtual async_signal */;
+
+template <typename T, typename Pointer, typename KeepAlives>
+struct async_addressable_value_with_keep_alives
+/* : async_value<T>, async_keep_alives<KeepAlives> */;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename Pointer>
+struct weak_promise;
+
+template <typename X, typename XPointer = pointer<X>>
+struct unique_eager_future_promise_pair final
+{
+  unique_eager_future<X>    future;
+  weak_promise<X, XPointer> promise;
+};
+
+struct acquired_stream final
+{
+  unique_stream stream;
+  optional<std::size_t> const acquired_from;
+  // `acquired_from` contains the index in the tuple of dependencies from which
+  // the stream was acquired. If `acquired_from` is empty, no stream could be
+  // acquired from a dependency, and then the stream was newly created.
+};
+
+// Precondition: `device` is the current CUDA device.
+template <typename X, typename Y, typename Deleter>
+__host__
+optional<unique_stream>
+try_acquire_stream(int device, std::unique_ptr<Y, Deleter>&) noexcept;
+
+// Precondition: `device` is the current CUDA device.
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int, unique_stream& stream) noexcept;
+
+// Precondition: `device` is the current CUDA device.
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int device, ready_event&) noexcept;
+
+// Precondition: `device` is the current CUDA device.
+template <typename X>
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int device, ready_future<X>&) noexcept;
+
+// Precondition: `device` is the current CUDA device.
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int device, unique_eager_event& parent) noexcept;
+
+// Precondition: `device` is the current CUDA device.
+template <typename X>
+__host__
+optional<unique_stream>
+try_acquire_stream(int device, unique_eager_future<X>& parent) noexcept;
+
+template <typename... Dependencies>
+__host__
+acquired_stream acquire_stream(int device, Dependencies&... deps) noexcept;
+  
+template <typename... Dependencies>
+__host__
+unique_eager_event
+make_dependent_event(
+  std::tuple<Dependencies...>&& deps
+);
+
+template <
+  typename X, typename XPointer
+, typename ComputeContent, typename... Dependencies
+>
+__host__
+unique_eager_future_promise_pair<X, XPointer>
+make_dependent_future(ComputeContent&& cc, std::tuple<Dependencies...>&& deps);
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct async_signal
+{
+protected:
+  unique_stream stream_;
+
+public:
+  // Constructs an `async_signal` which uses `stream`.
+  __host__
+  explicit async_signal(unique_stream&& stream)
+    : stream_(std::move(stream))
+  {}
+
+  __host__
+  virtual ~async_signal() {}
+
+  unique_stream&       stream()       noexcept { return stream_; }
+  unique_stream const& stream() const noexcept { return stream_; }
+};
+
+template <typename... KeepAlives>
+struct async_keep_alives<std::tuple<KeepAlives...>> : virtual async_signal
+{
+  using keep_alives_type = std::tuple<KeepAlives...>;
+
+protected:
+  keep_alives_type keep_alives_;
+
+public:
+  // Constructs an `async_keep_alives` which uses `stream`, and keeps the
+  // objects in the tuple `keep_alives` alive until the asynchronous signal is
+  // destroyed.
+  __host__
+  explicit async_keep_alives(
+    unique_stream&& stream, keep_alives_type&& keep_alives
+  )
+    : async_signal(std::move(stream))
+    , keep_alives_(std::move(keep_alives))
+  {}
+
+  __host__
+  virtual ~async_keep_alives() {}
+};
+
+template <typename T>
+struct async_value : virtual async_signal
+{
+  using value_type        = T;
+  using raw_const_pointer = value_type const*;
+
+  // Constructs an `async_value` which uses `stream` and has no content.
+  __host__
+  explicit async_value(unique_stream stream)
+    : async_signal(std::move(stream))
+  {}
+
+  __host__
+  virtual ~async_value() {}
+
+  __host__
+  virtual bool valid_content() const noexcept { return false; }
+
+  __host__
+  virtual value_type get()
+  {
+    throw thrust::event_error(event_errc::no_state);
+  }
+
+  __host__
+  virtual value_type extract()
+  {
+    throw thrust::event_error(event_errc::no_state);
+  }
+
+  // For testing only.
+  #if defined(THRUST_ENABLE_FUTURE_RAW_DATA_MEMBER)
+  __host__
+  virtual raw_const_pointer raw_data() const
+  {
+    return nullptr;
+  }
+  #endif
+};
+
+template <typename T, typename Pointer, typename... KeepAlives>
+struct async_addressable_value_with_keep_alives<
+  T, Pointer, std::tuple<KeepAlives...>
+> final
+  : async_value<T>, async_keep_alives<std::tuple<KeepAlives...>>
+{
+  using value_type        = typename async_value<T>::value_type;
+  using raw_const_pointer = typename async_value<T>::raw_const_pointer;
+
+  using keep_alives_type
+    = typename async_keep_alives<std::tuple<KeepAlives...>>::keep_alives_type;
+
+  using pointer
+    = typename thrust::detail::pointer_traits<Pointer>::template
+      rebind<value_type>::other;
+  using const_pointer
+    = typename thrust::detail::pointer_traits<Pointer>::template
+      rebind<value_type const>::other;
+
+private:
+  pointer content_;
+
+public:
+  // Constructs an `async_addressable_value_with_keep_alives` which uses
+  // `stream`, keeps the objects in the tuple `keep_alives` alive until the
+  // asynchronous value is destroyed, and determines the location of its
+  // content by evaluating `compute_content(content_keep_alive)`.
+  // NOTE: The use of a callback idiom is necessary if the content is stored in
+  // place in the content keep alive object, in which case we need to get its
+  // address after its been moved into the new signal we're constructing.
+  // NOTE: NVCC has a bug that causes it to reorder our base class initializers
+  // in generated host code, which leads to -Wreorder warnings.
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN
+  template <typename ComputeContent>
+  __host__
+  explicit async_addressable_value_with_keep_alives(
+    unique_stream&&    stream
+  , keep_alives_type&& keep_alives
+  , ComputeContent&&   compute_content
+  )
+    : async_signal(std::move(stream))
+    , async_value<T>(std::move(stream))
+    , async_keep_alives<keep_alives_type>(
+        std::move(stream), std::move(keep_alives)
+      )
+  {
+    content_ = THRUST_FWD(compute_content)(std::get<0>(this->keep_alives_));
+  }
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END
+
+  __host__
+  bool valid_content() const noexcept final override
+  {
+    return nullptr != content_;
+  }
+
+  // Precondition: `true == valid_content()`.
+  __host__
+  pointer data() 
+  {
+    if (!valid_content())
+      throw thrust::event_error(event_errc::no_content);
+
+    return content_;
+  }
+
+  // Precondition: `true == valid_content()`.
+  __host__
+  const_pointer data() const 
+  {
+    if (!valid_content())
+      throw thrust::event_error(event_errc::no_content);
+
+    return content_;
+  }
+
+  // Blocks.
+  // Precondition: `true == valid_content()`.
+  __host__
+  value_type get() final override
+  {
+    this->stream().wait();
+    return *data();
+  }
+
+  // Blocks.
+  // Precondition: `true == valid_content()`.
+  __host__
+  value_type extract() final override
+  {
+    this->stream().wait();
+    return std::move(*data());
+  }
+
+  // For testing only.
+  #if defined(THRUST_ENABLE_FUTURE_RAW_DATA_MEMBER)
+  __host__
+  raw_const_pointer raw_data() const final override
+  {
+    return raw_pointer_cast(content_);
+  }
+  #endif
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename Pointer>
+struct weak_promise final
+{
+  using value_type = typename async_value<T>::value_type;
+
+  using pointer
+    = typename thrust::detail::pointer_traits<Pointer>::template
+      rebind<T>::other;
+  using const_pointer
+    = typename thrust::detail::pointer_traits<Pointer>::template
+      rebind<T const>::other;
+
+private:
+  int device_ = 0;
+  pointer content_;
+
+  explicit weak_promise(int device_id, pointer content)
+    : device_(device_id), content_(std::move(content))
+  {}
+
+public:
+  __host__ __device__
+  weak_promise() : device_(0), content_{} {}
+
+  __thrust_exec_check_disable__
+  weak_promise(weak_promise const&) = default;
+  __thrust_exec_check_disable__
+  weak_promise(weak_promise&&) = default;
+  __thrust_exec_check_disable__
+  weak_promise& operator=(weak_promise const&) = default;
+  __thrust_exec_check_disable__
+  weak_promise& operator=(weak_promise&&) = default;
+
+  template <typename U>
+  __host__ __device__
+  void set_value(U&& value) &&
+  {
+    *content_ = THRUST_FWD(value);
+  }
+
+  template <
+    typename X, typename XPointer
+  , typename ComputeContent, typename... Dependencies
+  >
+  friend __host__
+  unique_eager_future_promise_pair<X, XPointer>
+  thrust::system::cuda::detail::make_dependent_future(
+    ComputeContent&& cc, std::tuple<Dependencies...>&& deps
+  );
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace detail
+
+struct ready_event final
+{
+  ready_event() = default;
+
+  template <typename U>
+  __host__ __device__
+  explicit ready_event(ready_future<U>) {}
+
+  __host__ __device__
+  static constexpr bool valid_content() noexcept { return true; }
+
+  __host__ __device__
+  static constexpr bool ready() noexcept { return true; }
+};
+
+template <typename T>
+struct ready_future final
+{
+  using value_type        = T;
+  using raw_const_pointer = T const*;
+
+private:
+  value_type value_;
+
+public:
+  __host__ __device__
+  ready_future() : value_{} {}
+
+  ready_future(ready_future&&) = default;
+  ready_future(ready_future const&) = default;
+  ready_future& operator=(ready_future&&) = default;
+  ready_future& operator=(ready_future const&) = default;
+
+  template <typename U>
+  __host__ __device__
+  explicit ready_future(U&& u) : value_(THRUST_FWD(u)) {}
+
+  __host__ __device__
+  static constexpr bool valid_content() noexcept { return true; }
+
+  __host__ __device__
+  static constexpr bool ready() noexcept { return true; }
+
+  __host__ __device__
+  value_type get() const
+  {
+    return value_;
+  }
+
+  THRUST_NODISCARD __host__ __device__
+  value_type extract() 
+  {
+    return std::move(value_);
+  }
+
+  #if defined(THRUST_ENABLE_FUTURE_RAW_DATA_MEMBER)
+  // For testing only.
+  __host__ __device__
+  raw_const_pointer data() const
+  {
+    return addressof(value_);
+  }
+  #endif
+};
+
+struct unique_eager_event final
+{
+protected:
+  int device_ = 0;
+  std::unique_ptr<detail::async_signal> async_signal_;
+
+  __host__
+  explicit unique_eager_event(
+    int device_id, std::unique_ptr<detail::async_signal> async_signal
+  )
+    : device_(device_id), async_signal_(std::move(async_signal))
+  {}
+
+public:
+  __host__
+  unique_eager_event()
+    : device_(0), async_signal_()
+  {}
+
+  unique_eager_event(unique_eager_event&&) = default;
+  unique_eager_event(unique_eager_event const&) = delete;
+  unique_eager_event& operator=(unique_eager_event&&) = default;
+  unique_eager_event& operator=(unique_eager_event const&) = delete;
+
+  // Any `unique_eager_future<T>` can be explicitly converted to a
+  // `unique_eager_event<void>`.
+  template <typename U>
+  __host__
+  explicit unique_eager_event(unique_eager_future<U>&& other)
+    // NOTE: We upcast to `unique_ptr<async_signal>` here.
+    : device_(other.where()), async_signal_(std::move(other.async_signal_))
+  {}
+
+  __host__
+  // NOTE: We take `new_stream_t` by `const&` because it is incomplete here.
+  explicit unique_eager_event(new_stream_t const&)
+    : device_(0)
+    , async_signal_(new detail::async_signal(detail::unique_stream{}))
+  {
+    thrust::cuda_cub::throw_on_error(cudaGetDevice(&device_));
+  }
+
+  __host__
+  virtual ~unique_eager_event()
+  {
+    // FIXME: If we could asynchronously handle destruction of keep alives, we
+    // could avoid doing this.
+    if (valid_stream()) wait();
+  }
+
+  __host__
+  bool valid_stream() const noexcept
+  {
+    return bool(async_signal_);
+  }
+
+  __host__
+  bool ready() const noexcept
+  {
+    if (valid_stream())
+      return stream().ready();
+    else
+      return false;
+  }
+
+  // Precondition: `true == valid_stream()`.
+  __host__
+  detail::unique_stream& stream()
+  {
+    if (!valid_stream())
+      throw thrust::event_error(event_errc::no_state);
+
+    return async_signal_->stream();
+  }
+  detail::unique_stream const& stream() const
+  {
+    if (!valid_stream())
+      throw thrust::event_error(event_errc::no_state);
+
+    return async_signal_->stream();
+  }
+
+  __host__
+  int where() const noexcept { return device_; }
+
+  // Precondition: `true == valid_stream()`.
+  __host__
+  void wait()
+  {
+    stream().wait();
+  }
+
+  friend __host__
+  optional<detail::unique_stream>
+  thrust::system::cuda::detail::try_acquire_stream(
+    int device_id, unique_eager_event& parent
+    ) noexcept;
+
+  template <typename... Dependencies>
+  friend __host__
+  unique_eager_event
+  thrust::system::cuda::detail::make_dependent_event(
+    std::tuple<Dependencies...>&& deps
+  );
+};
+
+template <typename T>
+struct unique_eager_future final
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (!std::is_same<T, remove_cvref_t<void>>::value)
+  , "`thrust::event` should be used to express valueless futures"
+  );
+
+  using value_type        = typename detail::async_value<T>::value_type;
+  using raw_const_pointer = typename detail::async_value<T>::raw_const_pointer;
+
+private:
+  int device_ = 0;
+  std::unique_ptr<detail::async_value<value_type>> async_signal_;
+
+  __host__
+  explicit unique_eager_future(
+    int device_id, std::unique_ptr<detail::async_value<value_type>> async_signal
+  )
+    : device_(device_id), async_signal_(std::move(async_signal))
+  {}
+
+public:
+  __host__
+  unique_eager_future()
+    : device_(0), async_signal_()
+  {}
+
+  unique_eager_future(unique_eager_future&&) = default;
+  unique_eager_future(unique_eager_future const&) = delete;
+  unique_eager_future& operator=(unique_eager_future&&) = default;
+  unique_eager_future& operator=(unique_eager_future const&) = delete;
+
+  __host__
+  // NOTE: We take `new_stream_t` by `const&` because it is incomplete here.
+  explicit unique_eager_future(new_stream_t const&)
+    : device_(0)
+    , async_signal_(new detail::async_value<value_type>(detail::unique_stream{}))
+  {
+    thrust::cuda_cub::throw_on_error(cudaGetDevice(&device_));
+  }
+
+  __host__
+  ~unique_eager_future()
+  {
+    // FIXME: If we could asynchronously handle destruction of keep alives, we
+    // could avoid doing this.
+    if (valid_stream()) wait();
+  }
+
+  __host__
+  bool valid_stream() const noexcept
+  {
+    return bool(async_signal_);
+  }
+
+  __host__
+  bool valid_content() const noexcept
+  {
+    if (!valid_stream())
+      return false;
+
+    // We might have been constructed with `new_stream_t`, in which case we'd
+    // have an async_value, but it doesn't have content.
+    return async_signal_->valid_content();
+  }
+
+  // Precondition: `true == valid_stream()`.
+  __host__
+  bool ready() const noexcept
+  {
+    if (valid_stream())
+      return stream().ready();
+    else
+      return false;
+  }
+
+  // Precondition: `true == valid_stream()`.
+  __host__
+  detail::unique_stream& stream()
+  {
+    if (!valid_stream())
+      throw thrust::event_error(event_errc::no_state);
+
+    return async_signal_->stream();
+  }
+  __host__
+  detail::unique_stream const& stream() const
+  {
+    if (!valid_stream())
+      throw thrust::event_error(event_errc::no_state);
+
+    return async_signal_->stream();
+  }
+
+  __host__
+  int where() const noexcept { return device_; }
+
+  // Blocks.
+  // Precondition: `true == valid_stream()`.
+  __host__
+  void wait()
+  {
+    stream().wait();
+  }
+
+  // Blocks.
+  // Precondition: `true == valid_content()`.
+  __host__
+  value_type get()
+  {
+    if (!valid_content())
+      throw thrust::event_error(event_errc::no_content);
+
+    return async_signal_->get();
+  }
+
+  // Blocks.
+  // Precondition: `true == valid_content()`.
+  THRUST_NODISCARD __host__
+  value_type extract()
+  {
+    if (!valid_content())
+      throw thrust::event_error(event_errc::no_content);
+
+    value_type tmp(async_signal_->extract());
+    async_signal_.reset();
+    return tmp;
+  }
+
+  // For testing only.
+  #if defined(THRUST_ENABLE_FUTURE_RAW_DATA_MEMBER)
+  // Precondition: `true == valid_stream()`.
+  __host__
+  raw_const_pointer raw_data() const
+  {
+    if (!valid_stream())
+      throw thrust::event_error(event_errc::no_state);
+
+    return async_signal_->raw_data();
+  }
+  #endif
+
+  template <typename X>
+  friend __host__
+  optional<detail::unique_stream>
+  thrust::system::cuda::detail::try_acquire_stream(
+    int device_id, unique_eager_future<X>& parent
+    ) noexcept;
+
+  template <
+    typename X, typename XPointer
+  , typename ComputeContent, typename... Dependencies
+  >
+  friend __host__
+  detail::unique_eager_future_promise_pair<X, XPointer>
+  thrust::system::cuda::detail::make_dependent_future(
+    ComputeContent&& cc, std::tuple<Dependencies...>&& deps
+  );
+
+  friend struct unique_eager_event;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace detail {
+
+template <typename X, typename Deleter>
+__host__
+optional<unique_stream>
+try_acquire_stream(int, std::unique_ptr<X, Deleter>&) noexcept
+{
+  // There's no stream to acquire!
+  return {};
+}
+
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int, unique_stream& stream) noexcept
+{
+  return {std::move(stream)};
+}
+
+inline __host__
+optional<unique_stream>
+try_acquire_stream(int, ready_event&) noexcept
+{
+  // There's no stream to acquire!
+  return {};
+}
+
+template <typename X>
+__host__
+optional<unique_stream>
+try_acquire_stream(int, ready_future<X>&) noexcept
+{
+  // There's no stream to acquire!
+  return {};
+}
+
+__host__
+optional<unique_stream>
+try_acquire_stream(int device_id, unique_eager_event& parent) noexcept
+{
+  // We have unique ownership, so we can always steal the stream if the future
+  // has one as long as they are on the same device as us.
+  if (parent.valid_stream())
+    if (device_id == parent.device_)
+      return std::move(parent.async_signal_->stream());
+
+  return {};
+}
+
+template <typename X>
+__host__
+optional<unique_stream>
+try_acquire_stream(int device_id, unique_eager_future<X>& parent) noexcept
+{
+  // We have unique ownership, so we can always steal the stream if the future
+  // has one as long as they are on the same device as us.
+  if (parent.valid_stream())
+    if (device_id == parent.device_)
+      return std::move(parent.async_signal_->stream());
+
+  return {};
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename... Dependencies>
+__host__
+acquired_stream acquire_stream_impl(
+  int, std::tuple<Dependencies...>&, index_sequence<>
+) noexcept
+{
+  // We tried to take a stream from all of our dependencies and failed every
+  // time, so we need to make a new stream.
+  return {unique_stream{}, {}};
+}
+
+template <typename... Dependencies, std::size_t I0, std::size_t... Is>
+__host__
+acquired_stream acquire_stream_impl(
+  int device_id
+, std::tuple<Dependencies...>& deps, index_sequence<I0, Is...>
+) noexcept
+{
+  auto tr = try_acquire_stream(device_id, std::get<I0>(deps));
+
+  if (tr)
+    return {std::move(*tr), {I0}};
+  else
+    return acquire_stream_impl(device_id, deps, index_sequence<Is...>{});
+}
+
+template <typename... Dependencies>
+__host__
+acquired_stream acquire_stream(
+  int device_id
+, std::tuple<Dependencies...>& deps
+) noexcept
+{
+  return acquire_stream_impl(
+    device_id, deps, make_index_sequence<sizeof...(Dependencies)>{}
+  );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename X, typename Deleter>
+__host__
+void create_dependency(
+  unique_stream&, std::unique_ptr<X, Deleter>&
+) noexcept
+{}
+
+inline __host__
+void create_dependency(
+  unique_stream&, ready_event&
+) noexcept
+{}
+
+template <typename T>
+__host__
+void create_dependency(
+  unique_stream&, ready_future<T>&
+) noexcept
+{}
+
+inline __host__
+void create_dependency(
+  unique_stream& child, unique_stream& parent
+)
+{
+  child.depend_on(parent);
+}
+
+inline __host__
+void create_dependency(
+  unique_stream& child, unique_eager_event& parent
+)
+{
+  child.depend_on(parent.stream());
+}
+
+template <typename X>
+__host__
+void create_dependency(
+  unique_stream& child, unique_eager_future<X>& parent
+)
+{
+  child.depend_on(parent.stream());
+}
+
+template <typename... Dependencies>
+__host__
+void create_dependencies_impl(
+  acquired_stream&
+, std::tuple<Dependencies...>&, index_sequence<>
+)
+{}
+
+template <typename... Dependencies, std::size_t I0, std::size_t... Is>
+__host__
+void create_dependencies_impl(
+  acquired_stream& as
+, std::tuple<Dependencies...>& deps, index_sequence<I0, Is...>
+)
+{
+  // We only need to wait on the current dependency if we didn't steal our
+  // stream from it.
+  if (!as.acquired_from || *as.acquired_from != I0)
+  {
+    create_dependency(as.stream, std::get<I0>(deps));
+  }
+
+  create_dependencies_impl(as, deps, index_sequence<Is...>{});
+}
+
+template <typename... Dependencies>
+__host__
+void create_dependencies(acquired_stream& as, std::tuple<Dependencies...>& deps)
+{
+  create_dependencies_impl(
+    as, deps, make_index_sequence<sizeof...(Dependencies)>{}
+  );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// Metafunction that determine which `Dependencies` need to be kept alive.
+// Returns the result as an `index_sequence` of indices into the parameter
+// pack.
+template <typename Tuple, typename Indices>
+  struct find_keep_alives_impl;
+template <typename Tuple>
+  using find_keep_alives
+    = typename find_keep_alives_impl<
+        Tuple, make_index_sequence<std::tuple_size<Tuple>::value>
+      >::type;
+
+template <>
+struct find_keep_alives_impl<
+  std::tuple<>, index_sequence<>
+>
+{
+  using type = index_sequence<>;
+};
+
+// User-provided stream.
+template <
+  typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<unique_stream, Dependencies...>, index_sequence<I0, Is...>
+>
+{
+  // Nothing to keep alive, skip this index.
+  using type = typename find_keep_alives_impl<
+    std::tuple<Dependencies...>, index_sequence<Is...>
+  >::type;
+};
+
+template <
+  typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<ready_event, Dependencies...>, index_sequence<I0, Is...>
+>
+{
+  // Nothing to keep alive, skip this index.
+  using type = typename find_keep_alives_impl<
+    std::tuple<Dependencies...>, index_sequence<Is...>
+  >::type;
+};
+
+template <
+  typename T, typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<ready_future<T>, Dependencies...>, index_sequence<I0, Is...>
+>
+{
+  // Add this index to the list.
+  using type = integer_sequence_push_front<
+    std::size_t, I0
+  , typename find_keep_alives_impl<
+      std::tuple<Dependencies...>, index_sequence<Is...>
+    >::type
+  >;
+};
+
+template <
+  typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<unique_eager_event, Dependencies...>
+, index_sequence<I0, Is...>
+>
+{
+  // Add this index to the list.
+  using type = integer_sequence_push_front<
+    std::size_t, I0
+  , typename find_keep_alives_impl<
+      std::tuple<Dependencies...>, index_sequence<Is...>
+    >::type
+  >;
+};
+
+template <
+  typename X, typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<unique_eager_future<X>, Dependencies...>
+, index_sequence<I0, Is...>
+>
+{
+  // Add this index to the list.
+  using type = integer_sequence_push_front<
+    std::size_t, I0
+  , typename find_keep_alives_impl<
+      std::tuple<Dependencies...>, index_sequence<Is...>
+    >::type
+  >;
+};
+
+// Content storage.
+template <
+  typename T, typename Deleter, typename... Dependencies
+, std::size_t I0, std::size_t... Is
+>
+struct find_keep_alives_impl<
+  std::tuple<std::unique_ptr<T, Deleter>, Dependencies...>
+, index_sequence<I0, Is...>
+>
+{
+  // Add this index to the list.
+  using type = integer_sequence_push_front<
+    std::size_t, I0
+  , typename find_keep_alives_impl<
+      std::tuple<Dependencies...>, index_sequence<Is...>
+    >::type
+  >;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename... Dependencies>
+__host__
+unique_eager_event make_dependent_event(std::tuple<Dependencies...>&& deps)
+{
+  int device_id = 0;
+  thrust::cuda_cub::throw_on_error(cudaGetDevice(&device_id));
+
+  // First, either steal a stream from one of our children or make a new one.
+  auto as = acquire_stream(device_id, deps);
+
+  // Then, make the stream we've acquired asynchronously wait on all of our
+  // dependencies, except the one we stole the stream from.
+  create_dependencies(as, deps);
+
+  // Then, we determine which subset of dependencies need to be kept alive.
+  auto ka = tuple_subset(
+    std::move(deps)
+  , find_keep_alives<std::tuple<Dependencies...>>{}
+  );
+
+  // Next, we create the asynchronous signal.
+  using async_signal_type = async_keep_alives<decltype(ka)>;
+
+  std::unique_ptr<async_signal_type> sig(
+    new async_signal_type(std::move(as.stream), std::move(ka))
+  );
+
+  // Finally, we create the event object.
+  return unique_eager_event(device_id, std::move(sig));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+  typename X, typename XPointer
+, typename ComputeContent, typename... Dependencies
+>
+__host__
+unique_eager_future_promise_pair<X, XPointer>
+make_dependent_future(ComputeContent&& cc, std::tuple<Dependencies...>&& deps)
+{
+  int device_id = 0;
+  thrust::cuda_cub::throw_on_error(cudaGetDevice(&device_id));
+
+  // First, either steal a stream from one of our children or make a new one.
+  auto as = acquire_stream(device_id, deps);
+
+  // Then, make the stream we've acquired asynchronously wait on all of our
+  // dependencies, except the one we stole the stream from.
+  create_dependencies(as, deps);
+
+  // Then, we determine which subset of dependencies need to be kept alive.
+  auto ka = tuple_subset(
+    std::move(deps)
+  , find_keep_alives<std::tuple<Dependencies...>>{}
+  );
+
+  // Next, we create the asynchronous value.
+  using async_signal_type = async_addressable_value_with_keep_alives<
+    X, XPointer, decltype(ka)
+  >;
+
+  std::unique_ptr<async_signal_type> sig(
+    new async_signal_type(std::move(as.stream), std::move(ka), std::move(cc))
+  );
+ 
+  // Finally, we create the promise and future objects.
+  weak_promise<X, XPointer> child_prom(device_id, sig->data());
+  unique_eager_future<X> child_fut(device_id, std::move(sig));
+
+  return unique_eager_future_promise_pair<X, XPointer>
+    {std::move(child_fut), std::move(child_prom)};
+}
+
+} // namespace detail
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename... Events>
+__host__
+unique_eager_event when_all(Events&&... evs)
+// TODO: Constrain to events, futures, and maybe streams (currently allows keep
+// alives).
+{
+  return detail::make_dependent_event(std::make_tuple(std::move(evs)...)); 
+}
+
+// ADL hook for transparent `.after` move support.
+inline __host__
+auto capture_as_dependency(unique_eager_event& dependency)
+THRUST_DECLTYPE_RETURNS(std::move(dependency))
+
+// ADL hook for transparent `.after` move support.
+template <typename X>
+__host__
+auto capture_as_dependency(unique_eager_future<X>& dependency)
+THRUST_DECLTYPE_RETURNS(std::move(dependency))
+
+}} // namespace system::cuda
+
+THRUST_NAMESPACE_END
+
+#endif // C++14
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/gather.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..56ff3aecf165069f2bb63ff7c6d2e8df78190f29
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/gather.h
@@ -0,0 +1,107 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/iterator/permutation_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class MapIt,
+          class ItemsIt,
+          class ResultIt>
+ResultIt __host__ __device__
+gather(execution_policy<Derived>& policy,
+    MapIt map_first,
+    MapIt map_last,
+    ItemsIt items,
+    ResultIt result)
+{
+  return cuda_cub::transform(policy,
+                          thrust::make_permutation_iterator(items, map_first),
+                          thrust::make_permutation_iterator(items, map_last),
+                          result,
+                          identity());
+}
+
+
+template <class Derived,
+          class MapIt,
+          class StencilIt,
+          class ItemsIt,
+          class ResultIt,
+          class Predicate>
+ResultIt __host__ __device__
+gather_if(execution_policy<Derived>& policy,
+          MapIt                      map_first,
+          MapIt                      map_last,
+          StencilIt                  stencil,
+          ItemsIt                    items,
+          ResultIt                   result,
+          Predicate                  predicate)
+{
+  return cuda_cub::transform_if(policy,
+                              thrust::make_permutation_iterator(items, map_first),
+                              thrust::make_permutation_iterator(items, map_last),
+                              stencil,
+                              result,
+                              identity(),
+                              predicate);
+}
+
+template <class Derived,
+          class MapIt,
+          class StencilIt,
+          class ItemsIt,
+          class ResultIt>
+ResultIt __host__ __device__
+gather_if(execution_policy<Derived>& policy,
+          MapIt                      map_first,
+          MapIt                      map_last,
+          StencilIt                  stencil,
+          ItemsIt                    items,
+          ResultIt                   result)
+{
+  return cuda_cub::gather_if(policy,
+                          map_first,
+                          map_last,
+                          stencil,
+                          items,
+                          result,
+                          identity());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/generate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/generate.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad6340f8313b7058b5755cfbfc5793b8c4a292ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/generate.h
@@ -0,0 +1,90 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/for_each.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+// for_each functor
+template <class Generator>
+struct generate_f
+{
+  Generator generator;
+
+  THRUST_FUNCTION
+  generate_f(Generator generator_) : generator(generator_) {}
+
+  template<class T>
+  THRUST_DEVICE_FUNCTION void operator()(T const& value)
+  {
+    T & lvalue = const_cast<T&>(value);
+    lvalue = generator();
+  }
+};
+
+// for_each_n
+template <class Derived,
+          class OutputIt,
+          class Size,
+          class Generator>
+OutputIt __host__ __device__
+generate_n(execution_policy<Derived> &policy,
+           OutputIt                   result,
+           Size                       count,
+           Generator                  generator)
+{
+  return cuda_cub::for_each_n(policy,
+                              result,
+                              count,
+                              generate_f<Generator>(generator));
+}
+
+  // for_each
+template <class Derived,
+          class OutputIt,
+          class Generator>
+void __host__ __device__
+generate(execution_policy<Derived> &policy,
+         OutputIt                   first,
+         OutputIt                   last,
+         Generator                  generator)
+{
+  cuda_cub::generate_n(policy, first, thrust::distance(first, last), generator);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/get_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/get_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..9065f773a801c57101b0501b189b82198d98220f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/get_value.h
@@ -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 THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cross_system.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/iterator/iterator_traits.h>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+namespace
+{
+
+
+template<typename DerivedPolicy, typename Pointer>
+inline __host__ __device__
+  typename thrust::iterator_value<Pointer>::type
+    get_value_msvc2005_war(execution_policy<DerivedPolicy> &exec, Pointer ptr)
+{
+  typedef typename thrust::iterator_value<Pointer>::type result_type;
+
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static result_type host_path(execution_policy<DerivedPolicy> &exec, Pointer ptr)
+    {
+      // when called from host code, implement with assign_value
+      // note that this requires a type with default constructor
+      result_type result;
+
+      thrust::host_system_tag host_tag;
+      cross_system<thrust::host_system_tag, DerivedPolicy> systems(host_tag, exec);
+      assign_value(systems, &result, ptr);
+
+      return result;
+    }
+
+    __device__ inline static result_type device_path(execution_policy<DerivedPolicy> &, Pointer ptr)
+    {
+      // when called from device code, just do simple deref
+      return *thrust::raw_pointer_cast(ptr);
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST,
+               (return war_nvbugs_881631::host_path(exec, ptr);),
+               (return war_nvbugs_881631::device_path(exec, ptr);))
+} // end get_value_msvc2005_war()
+} // end anon namespace
+
+
+template<typename DerivedPolicy, typename Pointer>
+inline __host__ __device__
+  typename thrust::iterator_value<Pointer>::type
+    get_value(execution_policy<DerivedPolicy> &exec, Pointer ptr)
+{
+  return get_value_msvc2005_war(exec,ptr);
+} // end get_value()
+
+
+} // end cuda_cub
+THRUST_NAMESPACE_END
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_cuda_runtime_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_cuda_runtime_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b0f345a74a4aa3b69027774be52fd9e0a5d09cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_cuda_runtime_api.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>
+
+// the purpose of this header is to check for the existence of macros
+// such as __host__ and __device__, which may already be defined by thrust
+// and to undefine them before entering cuda_runtime_api.h (which will redefine them)
+
+// we only try to do this stuff if cuda/include/host_defines.h has been included
+#if !defined(__HOST_DEFINES_H__)
+
+#ifdef __host__
+#undef __host__
+#endif // __host__
+
+#ifdef __device__
+#undef __device__
+#endif // __device__
+
+#endif // __HOST_DEFINES_H__
+
+#include <cuda_runtime_api.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_driver_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_driver_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..076964071cf78458de27fe54de3caf932ce93b40
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/guarded_driver_types.h
@@ -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>
+
+// the purpose of this header is to #include <driver_types.h> without causing
+// warnings from redefinitions of __host__ and __device__.
+// carefully save their definitions and restore them
+// can't tell exactly when push_macro & pop_macro were introduced to gcc; assume 4.5.0
+
+
+#if !defined(__GNUC__) || ((10000 * __GNUC__ + 100 * __GNUC_MINOR__ + __GNUC_PATCHLEVEL__) >= 40500)
+#  ifdef __host__
+#    pragma push_macro("__host__")
+#    undef __host__
+#    define THRUST_HOST_NEEDS_RESTORATION
+#  endif
+#  ifdef __device__
+#    pragma push_macro("__device__")
+#    undef __device__
+#    define THRUST_DEVICE_NEEDS_RESTORATION
+#  endif
+#else // GNUC pre 4.5.0
+#  if !defined(__DRIVER_TYPES_H__)
+#    ifdef __host__
+#      undef __host__
+#    endif
+#    ifdef __device__
+#      undef __device__
+#    endif
+#  endif // __DRIVER_TYPES_H__
+#endif // __GNUC__
+
+
+#include <driver_types.h>
+
+
+#if !defined(__GNUC__) || ((10000 * __GNUC__ + 100 * __GNUC_MINOR__ + __GNUC_PATCHLEVEL__) >= 40500)
+#  ifdef THRUST_HOST_NEEDS_RESTORATION
+#    pragma pop_macro("__host__")
+#    undef THRUST_HOST_NEEDS_RESTORATION
+#  endif
+#  ifdef THRUST_DEVICE_NEEDS_RESTORATION
+#    pragma pop_macro("__device__")
+#    undef THRUST_DEVICE_NEEDS_RESTORATION
+#  endif
+#endif // __GNUC__
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/inner_product.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/inner_product.h
new file mode 100644
index 0000000000000000000000000000000000000000..98e9064d286ff43245e2578302bdaa862804f4f7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/inner_product.h
@@ -0,0 +1,94 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class T,
+          class ReduceOp,
+          class ProductOp>
+T __host__ __device__
+inner_product(execution_policy<Derived> &policy,
+              InputIt1                   first1,
+              InputIt1                   last1,
+              InputIt2                   first2,
+              T                          init,
+              ReduceOp                   reduce_op,
+              ProductOp                  product_op)
+{
+  typedef typename iterator_traits<InputIt1>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first1, last1));
+  typedef transform_pair_of_input_iterators_t<T,
+                                              InputIt1,
+                                              InputIt2,
+                                              ProductOp>
+      binop_iterator_t;
+
+  return cuda_cub::reduce_n(policy,
+                            binop_iterator_t(first1, first2, product_op),
+                            num_items,
+                            init,
+                            reduce_op);
+}
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class T>
+T __host__ __device__
+inner_product(execution_policy<Derived> &policy,
+              InputIt1                   first1,
+              InputIt1                   last1,
+              InputIt2                   first2,
+              T                          init)
+{
+  return cuda_cub::inner_product(policy,
+                                 first1,
+                                 last1,
+                                 first2,
+                                 init,
+                                 plus<T>(),
+                                 multiplies<T>());
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_cross_system.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_cross_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1208c67c9a6f6510330aa4c23031f2460142d80
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_cross_system.h
@@ -0,0 +1,244 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditionu and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+// XXX
+// this file must not be included on its own, ever,
+// but must be part of include in thrust/system/cuda/detail/copy.h
+
+#include <thrust/detail/config.h>
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/distance.h>
+#include <thrust/advance.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/detail/uninitialized_copy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __copy {
+
+
+  template <class H,
+            class D,
+            class T,
+            class Size>
+  THRUST_HOST_FUNCTION void
+  trivial_device_copy(thrust::cpp::execution_policy<H>&      ,
+                      thrust::cuda_cub::execution_policy<D>& device_s,
+                      T*                                     dst,
+                      T const*                               src,
+                      Size                                   count)
+  {
+    cudaError status;
+    status = cuda_cub::trivial_copy_to_device(dst,
+                                              src,
+                                              count,
+                                              cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy::trivial_device_copy H->D: failed");
+  }
+
+  template <class D,
+            class H,
+            class T,
+            class Size>
+  THRUST_HOST_FUNCTION void
+  trivial_device_copy(thrust::cuda_cub::execution_policy<D>& device_s,
+                      thrust::cpp::execution_policy<H>&      ,
+                      T*                                     dst,
+                      T const*                               src,
+                      Size                                   count)
+  {
+    cudaError status;
+    status = cuda_cub::trivial_copy_from_device(dst,
+                                                src,
+                                                count,
+                                                cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "trivial_device_copy D->H failed");
+  }
+
+  template <class System1,
+            class System2,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::execution_policy<System1>& sys1,
+                      thrust::execution_policy<System2>& sys2,
+                      InputIt                            begin,
+                      Size                               n,
+                      OutputIt                           result,
+                      thrust::detail::true_type)    // trivial copy
+
+  {
+    typedef typename iterator_traits<InputIt>::value_type InputTy;
+    if (n > 0) {
+      trivial_device_copy(derived_cast(sys1),
+                          derived_cast(sys2),
+                          reinterpret_cast<InputTy*>(thrust::raw_pointer_cast(&*result)),
+                          reinterpret_cast<InputTy const*>(thrust::raw_pointer_cast(&*begin)),
+                          n);
+    }
+
+    return result + n;
+  }
+
+  // non-trivial H->D copy
+  template <class H,
+            class D,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::cpp::execution_policy<H>&      host_s,
+                      thrust::cuda_cub::execution_policy<D>& device_s,
+                      InputIt                                first,
+                      Size                                   num_items,
+                      OutputIt                               result,
+                      thrust::detail::false_type)    // non-trivial copy
+  {
+    // get type of the input data
+    typedef typename thrust::iterator_value<InputIt>::type InputTy;
+
+    // copy input data into host temp storage
+    InputIt last = first;
+    thrust::advance(last, num_items);
+    thrust::detail::temporary_array<InputTy, H> temp(host_s, num_items);
+
+    for (Size idx = 0; idx != num_items; idx++)
+    {
+      ::new (static_cast<void*>(temp.data().get()+idx)) InputTy(*first);
+      ++first;
+    }
+
+    // allocate device temporary storage
+    thrust::detail::temporary_array<InputTy, D> d_in_ptr(device_s, num_items);
+
+    // trivial copy data from host to device
+    cudaError status = cuda_cub::trivial_copy_to_device(d_in_ptr.data().get(),
+                                                        temp.data().get(),
+                                                        num_items,
+                                                        cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy:: H->D: failed");
+
+
+    // device->device copy
+    OutputIt ret = cuda_cub::copy_n(device_s, d_in_ptr.data(), num_items, result);
+
+    return ret;
+  }
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+  // non-trivial copy D->H, only supported with NVCC compiler
+  // because copy ctor must have  __device__ annotations, which is nvcc-only
+  // feature
+  template <class D,
+            class H,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(thrust::cuda_cub::execution_policy<D>& device_s,
+                      thrust::cpp::execution_policy<H>&   host_s,
+                      InputIt                             first,
+                      Size                                num_items,
+                      OutputIt                            result,
+                      thrust::detail::false_type)    // non-trivial copy
+
+  {
+    // get type of the input data
+    typedef typename thrust::iterator_value<InputIt>::type InputTy;
+
+    // allocate device temp storage 
+    thrust::detail::temporary_array<InputTy, D> d_in_ptr(device_s, num_items);
+
+    // uninitialize copy into temp device storage
+    cuda_cub::uninitialized_copy_n(device_s, first, num_items, d_in_ptr.data());
+
+    // allocate host temp storage
+    thrust::detail::temporary_array<InputTy, H> temp(host_s, num_items);
+
+    // trivial copy from device to host
+    cudaError status;
+    status = cuda_cub::trivial_copy_from_device(temp.data().get(),
+                                                d_in_ptr.data().get(),
+                                                num_items,
+                                                cuda_cub::stream(device_s));
+    cuda_cub::throw_on_error(status, "__copy:: D->H: failed");
+
+    // host->host copy
+    OutputIt ret = thrust::copy_n(host_s, temp.data(), num_items, result);
+
+    return ret;
+  }
+#endif
+
+  template <class System1,
+            class System2,
+            class InputIt,
+            class Size,
+            class OutputIt>
+  OutputIt __host__
+  cross_system_copy_n(cross_system<System1, System2> systems,
+                      InputIt  begin,
+                      Size     n,
+                      OutputIt result)
+  {
+    return cross_system_copy_n(
+        derived_cast(systems.sys1),
+        derived_cast(systems.sys2),
+        begin,
+        n,
+        result,
+        typename is_indirectly_trivially_relocatable_to<InputIt, OutputIt>::type());
+  }
+
+  template <class System1,
+            class System2,
+            class InputIterator,
+            class OutputIterator>
+  OutputIterator __host__
+  cross_system_copy(cross_system<System1, System2> systems,
+                    InputIterator  begin,
+                    InputIterator  end,
+                    OutputIterator result)
+  {
+    return cross_system_copy_n(systems,
+                               begin,
+                               thrust::distance(begin, end),
+                               result);
+  }
+
+}    // namespace __copy
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_device_to_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_device_to_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0d9d492dac5e314e393d5472b8bac0405c927ef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/internal/copy_device_to_device.h
@@ -0,0 +1,106 @@
+
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/type_traits/is_trivially_relocatable.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __copy {
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result,
+                   thrust::detail::true_type)
+  {
+    typedef typename thrust::iterator_traits<InputIt>::value_type InputTy;
+    const auto n = thrust::distance(first, last);
+    if (n > 0) {
+      cudaError status;
+      status = trivial_copy_device_to_device(policy,
+                                             reinterpret_cast<InputTy*>(thrust::raw_pointer_cast(&*result)),
+                                             reinterpret_cast<InputTy const*>(thrust::raw_pointer_cast(&*first)),
+                                             n);
+      cuda_cub::throw_on_error(status, "__copy:: D->D: failed");
+    }
+
+    return result + n;
+  }
+
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result,
+                   thrust::detail::false_type)
+  {
+    typedef typename thrust::iterator_traits<InputIt>::value_type InputTy;
+    return cuda_cub::transform(policy,
+                              first,
+                              last,
+                              result,
+                              thrust::identity<InputTy>());
+  }
+
+  template <class Derived,
+            class InputIt,
+            class OutputIt>
+  OutputIt THRUST_RUNTIME_FUNCTION
+  device_to_device(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result)
+  {
+    return device_to_device(policy,
+                            first,
+                            last,
+                            result,
+                            typename is_indirectly_trivially_relocatable_to<InputIt, OutputIt>::type());
+  }
+}    // namespace __copy
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/iter_swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/iter_swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0628610acbaaf0108d4ed29cdb44b003fdd97e0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/iter_swap.h
@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/swap.h>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+
+template<typename DerivedPolicy, typename Pointer1, typename Pointer2>
+inline __host__ __device__
+void iter_swap(thrust::cuda::execution_policy<DerivedPolicy> &, Pointer1 a, Pointer2 b)
+{
+  // XXX war nvbugs/881631
+  struct war_nvbugs_881631
+  {
+    __host__ inline static void host_path(Pointer1 a, Pointer2 b)
+    {
+      thrust::swap_ranges(a, a + 1, b);
+    }
+
+    __device__ inline static void device_path(Pointer1 a, Pointer2 b)
+    {
+      using thrust::swap;
+      swap(*thrust::raw_pointer_cast(a),
+           *thrust::raw_pointer_cast(b));
+    }
+  };
+
+  NV_IF_TARGET(NV_IS_HOST, (
+    war_nvbugs_881631::host_path(a, b);
+  ), (
+    war_nvbugs_881631::device_path(a, b);
+  ));
+
+} // end iter_swap()
+
+
+} // end cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/logical.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/logical.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/logical.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/make_unsigned_special.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/make_unsigned_special.h
new file mode 100644
index 0000000000000000000000000000000000000000..dda7357676012b85c190b30025dbdecbdbc4a318
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/make_unsigned_special.h
@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2019 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace detail {
+
+    template<typename Size>
+    struct make_unsigned_special;
+
+    template<>
+    struct make_unsigned_special<int> { typedef unsigned int type; };
+
+    // this is special, because CUDA's atomicAdd doesn't have an overload
+    // for unsigned long, for some godforsaken reason
+    template<>
+    struct make_unsigned_special<long> { typedef unsigned long long type; };
+
+    template<>
+    struct make_unsigned_special<long long> { typedef unsigned long long type; };
+
+}
+}
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/malloc_and_free.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/malloc_and_free.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b12e2cc305f73556648a3647b0c0fdd2156269e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/malloc_and_free.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.
+ */
+
+#pragma once
+
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/seq.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/detail/bad_alloc.h>
+#include <thrust/detail/malloc_and_free.h>
+
+#ifdef THRUST_CACHING_DEVICE_MALLOC
+#include <cub/util_allocator.cuh>
+#endif
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+#ifdef THRUST_CACHING_DEVICE_MALLOC
+#define __CUB_CACHING_MALLOC
+#ifndef __CUDA_ARCH__
+inline cub::CachingDeviceAllocator &get_allocator()
+{
+  static cub::CachingDeviceAllocator g_allocator(true);
+  return g_allocator;
+}
+#endif
+#endif
+
+
+// note that malloc returns a raw pointer to avoid
+// depending on the heavyweight thrust/system/cuda/memory.h header
+template<typename DerivedPolicy>
+__host__ __device__
+void *malloc(execution_policy<DerivedPolicy> &, std::size_t n)
+{
+  void *result = 0;
+
+  // need to repeat a lot of code here because we can't use #if inside of the
+  // NV_IF_TARGET macro.
+  // The device path is the same either way, but the host allocations differ.
+#ifdef __CUB_CACHING_MALLOC
+  NV_IF_TARGET(NV_IS_HOST, (
+    cub::CachingDeviceAllocator &alloc = get_allocator();
+    cudaError_t status = alloc.DeviceAllocate(&result, n);
+
+    if (status != cudaSuccess)
+    {
+      cudaGetLastError(); // Clear global CUDA error state.
+      throw thrust::system::detail::bad_alloc(thrust::cuda_category().message(status).c_str());
+    }
+  ), ( // NV_IS_DEVICE
+    result = thrust::raw_pointer_cast(thrust::malloc(thrust::seq, n));
+  ));
+#else // not __CUB_CACHING_MALLOC
+  NV_IF_TARGET(NV_IS_HOST, (
+    cudaError_t status = cudaMalloc(&result, n);
+
+    if (status != cudaSuccess)
+    {
+      cudaGetLastError(); // Clear global CUDA error state.
+      throw thrust::system::detail::bad_alloc(thrust::cuda_category().message(status).c_str());
+    }
+  ), ( // NV_IS_DEVICE
+    result = thrust::raw_pointer_cast(thrust::malloc(thrust::seq, n));
+  ));
+#endif
+
+  return result;
+} // end malloc()
+
+
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+void free(execution_policy<DerivedPolicy> &, Pointer ptr)
+{
+  // need to repeat a lot of code here because we can't use #if inside of the
+  // NV_IF_TARGET macro.
+  // The device path is the same either way, but the host deallocations differ.
+#ifdef __CUB_CACHING_MALLOC
+  NV_IF_TARGET(NV_IS_HOST, (
+    cub::CachingDeviceAllocator &alloc = get_allocator();
+    cudaError_t status = alloc.DeviceFree(thrust::raw_pointer_cast(ptr));
+    cuda_cub::throw_on_error(status, "device free failed");
+  ), ( // NV_IS_DEVICE
+    thrust::free(thrust::seq, ptr);
+  ));
+#else // not __CUB_CACHING_MALLOC
+  NV_IF_TARGET(NV_IS_HOST, (
+    cudaError_t status = cudaFree(thrust::raw_pointer_cast(ptr));
+    cuda_cub::throw_on_error(status, "device free failed");
+  ), ( // NV_IS_DEVICE
+    thrust::free(thrust::seq, ptr);
+  ));
+#endif
+} // end free()
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/memory.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/memory.inl
new file mode 100644
index 0000000000000000000000000000000000000000..f6fc98359af2279c232add4b8ef35931cd7f2478
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/memory.inl
@@ -0,0 +1,52 @@
+/*
+ *  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>
+#include <thrust/system/cuda/memory.h>
+#include <thrust/system/cuda/detail/malloc_and_free.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+
+__host__ __device__
+pointer<void> malloc(std::size_t n)
+{
+  tag cuda_tag;
+  return pointer<void>(thrust::cuda_cub::malloc(cuda_tag, n));
+} // end malloc()
+
+template<typename T>
+__host__ __device__
+pointer<T> malloc(std::size_t n)
+{
+  pointer<void> raw_ptr = thrust::cuda_cub::malloc(sizeof(T) * n);
+  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
+} // end malloc()
+
+__host__ __device__
+void free(pointer<void> ptr)
+{
+  tag cuda_tag;
+  return thrust::cuda_cub::free(cuda_tag, ptr.get());
+} // end free()
+
+} // end cuda_cub
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/merge.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/merge.h
new file mode 100644
index 0000000000000000000000000000000000000000..478e3508d70ac96352bff1e17b47841d5f56d1c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/merge.h
@@ -0,0 +1,998 @@
+/******************************************************************************
+j * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/merge.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __merge {
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class Size,
+            class BinaryPred>
+  Size THRUST_DEVICE_FUNCTION
+  merge_path(KeysIt1    keys1,
+             KeysIt2    keys2,
+             Size       keys1_count,
+             Size       keys2_count,
+             Size       diag,
+             BinaryPred binary_pred)
+  {
+    typedef typename iterator_traits<KeysIt1>::value_type key1_type;
+    typedef typename iterator_traits<KeysIt2>::value_type key2_type;
+
+    Size keys1_begin = thrust::max<Size>(0, diag - keys2_count);
+    Size keys1_end   = thrust::min<Size>(diag, keys1_count);
+
+    while (keys1_begin < keys1_end)
+    {
+      Size mid = (keys1_begin + keys1_end) >> 1;
+      key1_type key1 = keys1[mid];
+      key2_type key2 = keys2[diag - 1 - mid];
+      bool pred = binary_pred(key2, key1);
+      if (pred)
+      {
+        keys1_end = mid;
+      }
+      else
+      {
+        keys1_begin = mid+1;
+      }
+    }
+    return keys1_begin;
+  }
+
+  template <class It, class T2, class CompareOp, int ITEMS_PER_THREAD>
+  THRUST_DEVICE_FUNCTION void
+  serial_merge(It  keys_shared,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T2 (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+  {
+    int keys1_end = keys1_beg + keys1_count;
+    int keys2_end = keys2_beg + keys2_count;
+
+    typedef typename iterator_value<It>::type key_type;
+
+    key_type key1 = keys_shared[keys1_beg];
+    key_type key2 = keys_shared[keys2_beg];
+
+
+#pragma unroll
+    for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+    {
+      bool p = (keys2_beg < keys2_end) &&
+               ((keys1_beg >= keys1_end) ||
+                compare_op(key2,key1));
+
+      output[ITEM]  = p ? key2 : key1;
+      indices[ITEM] = p ? keys2_beg++ : keys1_beg++;
+
+      if (p)
+      {
+        key2 = keys_shared[keys2_beg];
+      }
+      else
+      {
+        key1 = keys_shared[keys1_beg];
+      }
+    }
+  }
+
+  template <int                      _BLOCK_THREADS,
+            int                      _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm  _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier   _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockStoreAlgorithm _STORE_ALGORITHM  = cub::BLOCK_STORE_DIRECT>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS      = _BLOCK_THREADS,
+      ITEMS_PER_THREAD   = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE     = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+
+    static const cub::BlockLoadAlgorithm  LOAD_ALGORITHM  = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier   LOAD_MODIFIER   = _LOAD_MODIFIER;
+    static const cub::BlockStoreAlgorithm STORE_ALGORITHM = _STORE_ALGORITHM;
+  };    // PtxPolicy
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class Size,
+            class CompareOp>
+  struct PartitionAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<256> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    THRUST_AGENT_ENTRY(KeysIt1   keys1,
+                       KeysIt2   keys2,
+                       Size      keys1_count,
+                       Size      keys2_count,
+                       Size      num_partitions,
+                       Size*     merge_partitions,
+                       CompareOp compare_op,
+                       int       items_per_tile,
+                       char*     /*shmem*/)
+    {
+      Size partition_idx = blockDim.x * blockIdx.x + threadIdx.x;
+      if (partition_idx < num_partitions)
+      {
+        Size partition_at = (thrust::min)(partition_idx * items_per_tile,
+                                        keys1_count + keys2_count);
+        Size partition_diag = merge_path(keys1,
+                                         keys2,
+                                         keys1_count,
+                                         keys2_count,
+                                         partition_at,
+                                         compare_op);
+        merge_partitions[partition_idx] = partition_diag;
+      }
+    }
+  };    // struct PartitionAgent
+
+
+  template <class Arch, class TSize>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<int NOMINAL_4B_ITEMS_PER_THREAD, size_t INPUT_SIZE>
+  struct items_per_thread
+  {
+    enum
+    {
+      ITEMS_PER_THREAD =
+          mpl::min<
+              int,
+              NOMINAL_4B_ITEMS_PER_THREAD,
+              mpl::max<
+                  int,
+                  1,
+                  static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD * 4 / INPUT_SIZE)>::value>::value,
+      value = mpl::is_odd<int, ITEMS_PER_THREAD>::value
+                  ? ITEMS_PER_THREAD
+                  : ITEMS_PER_THREAD + 1
+    };
+  };
+
+  template<class TSize>
+  struct Tuning<sm30,TSize>
+  {
+    const static int INPUT_SIZE = TSize::value;
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = items_per_thread<NOMINAL_4B_ITEMS_PER_THREAD,
+                                          INPUT_SIZE>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_STORE_WARP_TRANSPOSE>
+        type;
+  };    // Tuning sm300
+
+
+
+  template<class TSize>
+  struct Tuning<sm60,TSize> : Tuning<sm30,TSize>
+  {
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 15,
+      ITEMS_PER_THREAD            = items_per_thread<NOMINAL_4B_ITEMS_PER_THREAD,
+                                          Tuning::INPUT_SIZE>::value
+    };
+
+
+    typedef PtxPolicy<512,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_STORE_WARP_TRANSPOSE>
+        type;
+  };    // Tuning sm52
+
+  template<class TSize>
+  struct Tuning<sm52,TSize> : Tuning<sm30,TSize>
+  {
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 13,
+      ITEMS_PER_THREAD            = items_per_thread<NOMINAL_4B_ITEMS_PER_THREAD,
+                                          Tuning::INPUT_SIZE>::value
+    };
+
+    typedef PtxPolicy<512,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_STORE_WARP_TRANSPOSE>
+        type;
+  };    // Tuning sm52
+
+  template<class TSize>
+  struct Tuning<sm35,TSize> : Tuning<sm30,TSize>
+  {
+    const static int INPUT_SIZE = TSize::value;
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 11,
+      ITEMS_PER_THREAD            = items_per_thread<NOMINAL_4B_ITEMS_PER_THREAD,
+                                          Tuning::INPUT_SIZE>::value
+    };
+
+
+    typedef PtxPolicy<256,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_STORE_WARP_TRANSPOSE>
+        type;
+  };    // Tuning sm350
+
+
+  template<size_t VALUE>
+  struct integer_constant : thrust::detail::integral_constant<size_t, VALUE> {};
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class ItemsIt1,
+            class ItemsIt2,
+            class Size,
+            class KeysOutputIt,
+            class ItemsOutputIt,
+            class CompareOp,
+            class MERGE_ITEMS>
+  struct MergeAgent
+  {
+    typedef typename iterator_traits<KeysIt1>::value_type  key1_type;
+    typedef typename iterator_traits<KeysIt2>::value_type  key2_type;
+    typedef typename iterator_traits<ItemsIt1>::value_type item1_type;
+    typedef typename iterator_traits<ItemsIt2>::value_type item2_type;
+
+    typedef key1_type  key_type;
+    typedef item1_type item_type;
+
+    typedef typename thrust::detail::conditional<
+        MERGE_ITEMS::value,
+        integer_constant<sizeof(key_type) + sizeof(item_type)>,
+        integer_constant<sizeof(key_type)> >::type tuning_type;
+
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, tuning_type>::type
+    {
+      typedef Tuning<Arch,tuning_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeysIt1>::type  KeysLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, KeysIt2>::type  KeysLoadIt2;
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt1>::type ItemsLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt2>::type ItemsLoadIt2;
+
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt1>::type  BlockLoadKeys1;
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt2>::type  BlockLoadKeys2;
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt1>::type BlockLoadItems1;
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt2>::type BlockLoadItems2;
+
+      typedef typename core::BlockStore<PtxPlan,
+                                        KeysOutputIt,
+                                        key_type>::type BlockStoreKeys;
+      typedef typename core::BlockStore<PtxPlan,
+                                        ItemsOutputIt,
+                                        item_type>::type BlockStoreItems;
+
+      // gather required temporary storage in a union
+      //
+      union TempStorage
+      {
+        typename BlockLoadKeys1::TempStorage  load_keys1;
+        typename BlockLoadKeys2::TempStorage  load_keys2;
+        typename BlockLoadItems1::TempStorage load_items1;
+        typename BlockLoadItems2::TempStorage load_items2;
+        typename BlockStoreKeys::TempStorage  store_keys;
+        typename BlockStoreItems::TempStorage store_items;
+
+        core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE + 1> items_shared;
+        core::uninitialized_array<key_type, PtxPlan::ITEMS_PER_TILE + 1>  keys_shared;
+      };    // union TempStorage
+    };    // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeysLoadIt1     KeysLoadIt1;
+    typedef typename ptx_plan::KeysLoadIt2     KeysLoadIt2;
+    typedef typename ptx_plan::ItemsLoadIt1    ItemsLoadIt1;
+    typedef typename ptx_plan::ItemsLoadIt2    ItemsLoadIt2;
+    typedef typename ptx_plan::BlockLoadKeys1  BlockLoadKeys1;
+    typedef typename ptx_plan::BlockLoadKeys2  BlockLoadKeys2;
+    typedef typename ptx_plan::BlockLoadItems1 BlockLoadItems1;
+    typedef typename ptx_plan::BlockLoadItems2 BlockLoadItems2;
+    typedef typename ptx_plan::BlockStoreKeys  BlockStoreKeys;
+    typedef typename ptx_plan::BlockStoreItems BlockStoreItems;
+    typedef typename ptx_plan::TempStorage     TempStorage;
+
+    enum
+    {
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per thread data
+      //---------------------------------------------------------------------
+
+      TempStorage&  storage;
+      KeysLoadIt1   keys1_in;
+      KeysLoadIt2   keys2_in;
+      ItemsLoadIt1  items1_in;
+      ItemsLoadIt2  items2_in;
+      Size          keys1_count;
+      Size          keys2_count;
+      KeysOutputIt  keys_out;
+      ItemsOutputIt items_out;
+      CompareOp     compare_op;
+      Size*         merge_partitions;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      template <bool IS_FULL_TILE, class T, class It1, class It2>
+      THRUST_DEVICE_FUNCTION void
+      gmem_to_reg(T (&output)[ITEMS_PER_THREAD],
+                  It1 input1,
+                  It2 input2,
+                  int count1,
+                  int count2)
+      {
+        if (IS_FULL_TILE)
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+            if (idx < count1)
+              output[ITEM] = input1[idx];
+            else
+              output[ITEM] = input2[idx - count1];
+          }
+        }
+        else
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+            if (idx < count1 + count2)
+            {
+              if (idx < count1)
+                output[ITEM] = input1[idx];
+              else
+                output[ITEM] = input2[idx - count1];
+            }
+          }
+        }
+      }
+
+      template <class T, class It>
+      THRUST_DEVICE_FUNCTION void
+      reg_to_shared(It output,
+                    T (&input)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+          output[idx] = input[ITEM];
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_FULL_TILE>
+      void THRUST_DEVICE_FUNCTION
+      consume_tile(Size tile_idx,
+                   Size tile_base,
+                   int  num_remaining)
+      {
+        using core::sync_threadblock;
+        using core::uninitialized_array;
+
+        Size partition_beg = merge_partitions[tile_idx + 0];
+        Size partition_end = merge_partitions[tile_idx + 1];
+
+        Size diag0 = ITEMS_PER_TILE * tile_idx;
+        Size diag1 = (thrust::min)(keys1_count + keys2_count, diag0 + ITEMS_PER_TILE);
+
+        // compute bounding box for keys1 & keys2
+        //
+        Size keys1_beg = partition_beg;
+        Size keys1_end = partition_end;
+        Size keys2_beg = diag0 - keys1_beg;
+        Size keys2_end = diag1 - keys1_end;
+
+        // number of keys per tile
+        //
+        int num_keys1 = static_cast<int>(keys1_end - keys1_beg);
+        int num_keys2 = static_cast<int>(keys2_end - keys2_beg);
+
+        key_type keys_loc[ITEMS_PER_THREAD];
+        gmem_to_reg<IS_FULL_TILE>(keys_loc,
+                                  keys1_in + keys1_beg,
+                                  keys2_in + keys2_beg,
+                                  num_keys1,
+                                  num_keys2);
+        reg_to_shared(&storage.keys_shared[0], keys_loc);
+
+        sync_threadblock();
+
+        // use binary search in shared memory
+        // to find merge path for each of thread
+        // we can use int type here, because the number of
+        // items in shared memory is limited
+        //
+        int diag0_loc = min<int>(num_keys1 + num_keys2,
+                                 ITEMS_PER_THREAD * threadIdx.x);
+
+        int keys1_beg_loc = merge_path(&storage.keys_shared[0],
+                                       &storage.keys_shared[num_keys1],
+                                       num_keys1,
+                                       num_keys2,
+                                       diag0_loc,
+                                       compare_op);
+        int keys1_end_loc = num_keys1;
+        int keys2_beg_loc = diag0_loc - keys1_beg_loc;
+        int keys2_end_loc = num_keys2;
+
+        int num_keys1_loc = keys1_end_loc - keys1_beg_loc;
+        int num_keys2_loc = keys2_end_loc - keys2_beg_loc;
+
+        // perform serial merge
+        //
+        int indices[ITEMS_PER_THREAD];
+
+        serial_merge(&storage.keys_shared[0],
+                     keys1_beg_loc,
+                     keys2_beg_loc + num_keys1,
+                     num_keys1_loc,
+                     num_keys2_loc,
+                     keys_loc,
+                     indices,
+                     compare_op);
+
+        sync_threadblock();
+
+        // write keys
+        //
+        if (IS_FULL_TILE)
+        {
+          BlockStoreKeys(storage.store_keys)
+              .Store(keys_out + tile_base, keys_loc);
+        }
+        else
+        {
+          BlockStoreKeys(storage.store_keys)
+              .Store(keys_out + tile_base, keys_loc, num_remaining);
+        }
+
+        // if items are provided, merge them
+        if (MERGE_ITEMS::value)
+        {
+          item_type items_loc[ITEMS_PER_THREAD];
+          gmem_to_reg<IS_FULL_TILE>(items_loc,
+                                    items1_in + keys1_beg,
+                                    items2_in + keys2_beg,
+                                    num_keys1,
+                                    num_keys2);
+
+          sync_threadblock();
+
+          reg_to_shared(&storage.items_shared[0], items_loc);
+
+          sync_threadblock();
+
+          // gather items from shared mem
+          //
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            items_loc[ITEM] = storage.items_shared[indices[ITEM]];
+          }
+
+          sync_threadblock();
+
+          // write form reg to gmem
+          //
+          if (IS_FULL_TILE)
+          {
+            BlockStoreItems(storage.store_items)
+                .Store(items_out + tile_base, items_loc);
+          }
+          else
+          {
+            BlockStoreItems(storage.store_items)
+                .Store(items_out + tile_base, items_loc, num_remaining);
+          }
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage&  storage_,
+           KeysLoadIt1   keys1_in_,
+           KeysLoadIt2   keys2_in_,
+           ItemsLoadIt1  items1_in_,
+           ItemsLoadIt2  items2_in_,
+           Size          keys1_count_,
+           Size          keys2_count_,
+           KeysOutputIt  keys_out_,
+           ItemsOutputIt items_out_,
+           CompareOp     compare_op_,
+           Size*         merge_partitions_)
+          : storage(storage_),
+            keys1_in(keys1_in_),
+            keys2_in(keys2_in_),
+            items1_in(items1_in_),
+            items2_in(items2_in_),
+            keys1_count(keys1_count_),
+            keys2_count(keys2_count_),
+            keys_out(keys_out_),
+            items_out(items_out_),
+            compare_op(compare_op_),
+            merge_partitions(merge_partitions_)
+      {
+        // XXX with 8.5 chaging type to Size (or long long) results in error!
+        int  tile_idx      = blockIdx.x;
+        Size  tile_base     = tile_idx * ITEMS_PER_TILE;
+        int  items_in_tile = static_cast<int>(
+            min<Size>(ITEMS_PER_TILE,
+                      keys1_count + keys2_count - tile_base));
+        if (items_in_tile == ITEMS_PER_TILE)
+        {
+          // full tile
+          consume_tile<true>(tile_idx,
+                             tile_base,
+                             ITEMS_PER_TILE);
+        }
+        else
+        {
+          // partial tile
+          consume_tile<false>(tile_idx,
+                              tile_base,
+                              items_in_tile);
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysIt1       keys1_in,
+                       KeysIt2       keys2_in,
+                       ItemsIt1      items1_in,
+                       ItemsIt2      items2_in,
+                       Size          keys1_count,
+                       Size          keys2_count,
+                       KeysOutputIt  keys_out,
+                       ItemsOutputIt items_out,
+                       CompareOp     compare_op,
+                       Size*         merge_partitions,
+                       char*         shmem)
+    {
+      TempStorage& storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      impl(storage,
+           core::make_load_iterator(ptx_plan(), keys1_in),
+           core::make_load_iterator(ptx_plan(), keys2_in),
+           core::make_load_iterator(ptx_plan(), items1_in),
+           core::make_load_iterator(ptx_plan(), items2_in),
+           keys1_count,
+           keys2_count,
+           keys_out,
+           items_out,
+           compare_op,
+           merge_partitions);
+    }
+  };    // struct MergeAgent;
+
+  //---------------------------------------------------------------------
+  // Two-step internal API
+  //---------------------------------------------------------------------
+
+  template <class MERGE_ITEMS,
+            class KeysIt1,
+            class KeysIt2,
+            class ItemsIt1,
+            class ItemsIt2,
+            class Size,
+            class KeysOutputIt,
+            class ItemsOutputIt,
+            class CompareOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void*         d_temp_storage,
+            size_t&       temp_storage_bytes,
+            KeysIt1       keys1,
+            KeysIt2       keys2,
+            ItemsIt1      items1,
+            ItemsIt2      items2,
+            Size          num_keys1,
+            Size          num_keys2,
+            KeysOutputIt  keys_result,
+            ItemsOutputIt items_result,
+            CompareOp     compare_op,
+            cudaStream_t  stream)
+  {
+    if (num_keys1 + num_keys2 == 0)
+      return cudaErrorNotSupported;
+
+    using core::AgentPlan;
+    using core::get_agent_plan;
+    typedef core::AgentLauncher<
+        MergeAgent<KeysIt1,
+                   KeysIt2,
+                   ItemsIt1,
+                   ItemsIt2,
+                   Size,
+                   KeysOutputIt,
+                   ItemsOutputIt,
+                   CompareOp,
+                   MERGE_ITEMS> >
+        merge_agent;
+
+    typedef core::AgentLauncher<
+        PartitionAgent<KeysIt1,
+                       KeysIt2,
+                       Size,
+                       CompareOp> >
+        partition_agent;
+
+    cudaError_t status = cudaSuccess;
+
+    AgentPlan partition_plan = partition_agent::get_plan();
+    AgentPlan merge_plan     = merge_agent::get_plan(stream);
+
+    int  tile_size = merge_plan.items_per_tile;
+    Size num_tiles = (num_keys1 + num_keys2 + tile_size - 1) / tile_size;
+
+    size_t temp_storage1 = (1 + num_tiles) * sizeof(Size);
+    size_t temp_storage2 = core::vshmem_size(merge_plan.shared_memory_size,
+                                             num_tiles);
+
+    void*  allocations[2]      = {NULL, NULL};
+    size_t allocation_sizes[2] = {temp_storage1, temp_storage2};
+
+    status = core::alias_storage(d_temp_storage,
+                                 temp_storage_bytes,
+                                 allocations,
+                                 allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    // partition data into work balanced tiles
+    Size* merge_partitions = (Size*)allocations[0];
+    char* vshmem_ptr       = temp_storage2 > 0 ? (char*)allocations[1] : NULL;
+
+    {
+      Size num_partitions = num_tiles + 1;
+
+      partition_agent(partition_plan, num_partitions, stream, "partition agent")
+          .launch(keys1,
+                  keys2,
+                  num_keys1,
+                  num_keys2,
+                  num_partitions,
+                  merge_partitions,
+                  compare_op,
+                  merge_plan.items_per_tile);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    }
+
+    merge_agent(merge_plan, num_keys1 + num_keys2, stream, vshmem_ptr, "merge agent")
+        .launch(keys1,
+                keys2,
+                items1,
+                items2,
+                num_keys1,
+                num_keys2,
+                keys_result,
+                items_result,
+                compare_op,
+                merge_partitions);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    return status;
+  }
+
+  template <typename MERGE_ITEMS,
+            typename Derived,
+            typename KeysIt1,
+            typename KeysIt2,
+            typename ItemsIt1,
+            typename ItemsIt2,
+            typename KeysOutputIt,
+            typename ItemsOutputIt,
+            typename CompareOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ItemsOutputIt>
+  merge(execution_policy<Derived>& policy,
+        KeysIt1                    keys1_first,
+        KeysIt1                    keys1_last,
+        KeysIt2                    keys2_first,
+        KeysIt2                    keys2_last,
+        ItemsIt1                   items1_first,
+        ItemsIt2                   items2_first,
+        KeysOutputIt               keys_result,
+        ItemsOutputIt              items_result,
+        CompareOp                  compare_op)
+  {
+    typedef typename iterator_traits<KeysIt1>::difference_type size_type;
+
+    size_type num_keys1
+      = static_cast<size_type>(thrust::distance(keys1_first, keys1_last));
+    size_type num_keys2
+      = static_cast<size_type>(thrust::distance(keys2_first, keys2_last));
+
+    size_type const count = num_keys1 + num_keys2;
+
+    if (count == 0)
+      return thrust::make_pair(keys_result, items_result);
+
+    size_t       storage_size = 0;
+    cudaStream_t stream       = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step<MERGE_ITEMS>(NULL,
+                                    storage_size,
+                                    keys1_first,
+                                    keys2_first,
+                                    items1_first,
+                                    items2_first,
+                                    num_keys1,
+                                    num_keys2,
+                                    keys_result,
+                                    items_result,
+                                    compare_op,
+                                    stream);
+    cuda_cub::throw_on_error(status, "merge: failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = doit_step<MERGE_ITEMS>(ptr,
+                                    storage_size,
+                                    keys1_first,
+                                    keys2_first,
+                                    items1_first,
+                                    items2_first,
+                                    num_keys1,
+                                    num_keys2,
+                                    keys_result,
+                                    items_result,
+                                    compare_op,
+                                    stream);
+    cuda_cub::throw_on_error(status, "merge: failed on 2nd step");
+
+    status = cuda_cub::synchronize_optional(policy);
+    cuda_cub::throw_on_error(status, "merge: failed to synchronize");
+
+    return thrust::make_pair(keys_result + count, items_result + count);
+  }
+}    // namespace __merge
+
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ResultIt,
+          class CompareOp>
+ResultIt __host__ __device__
+merge(execution_policy<Derived>& policy,
+      KeysIt1                    keys1_first,
+      KeysIt1                    keys1_last,
+      KeysIt2                    keys2_first,
+      KeysIt2                    keys2_last,
+      ResultIt                   result,
+      CompareOp                  compare_op)
+
+{
+  THRUST_CDP_DISPATCH((using keys_type  = thrust::iterator_value_t<KeysIt1>;
+                       keys_type *null_ = nullptr;
+                       auto tmp =
+                         __merge::merge<thrust::detail::false_type>(policy,
+                                                                    keys1_first,
+                                                                    keys1_last,
+                                                                    keys2_first,
+                                                                    keys2_last,
+                                                                    null_,
+                                                                    null_,
+                                                                    result,
+                                                                    null_,
+                                                                    compare_op);
+                       result = tmp.first;),
+                      (result = thrust::merge(cvt_to_seq(derived_cast(policy)),
+                                              keys1_first,
+                                              keys1_last,
+                                              keys2_first,
+                                              keys2_last,
+                                              result,
+                                              compare_op);));
+  return result;
+}
+
+template <class Derived, class KeysIt1, class KeysIt2, class ResultIt>
+ResultIt __host__ __device__
+merge(execution_policy<Derived>& policy,
+      KeysIt1                    keys1_first,
+      KeysIt1                    keys1_last,
+      KeysIt2                    keys2_first,
+      KeysIt2                    keys2_last,
+      ResultIt                   result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type keys_type;
+  return cuda_cub::merge(policy,
+                         keys1_first,
+                         keys1_last,
+                         keys2_first,
+                         keys2_last,
+                         result,
+                         less<keys_type>());
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+merge_by_key(execution_policy<Derived> &policy,
+             KeysIt1                    keys1_first,
+             KeysIt1                    keys1_last,
+             KeysIt2                    keys2_first,
+             KeysIt2                    keys2_last,
+             ItemsIt1                   items1_first,
+             ItemsIt2                   items2_first,
+             KeysOutputIt               keys_result,
+             ItemsOutputIt              items_result,
+             CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __merge::merge<thrust::detail::true_type>(policy,
+                                                     keys1_first,
+                                                     keys1_last,
+                                                     keys2_first,
+                                                     keys2_last,
+                                                     items1_first,
+                                                     items2_first,
+                                                     keys_result,
+                                                     items_result,
+                                                     compare_op);),
+    (ret = thrust::merge_by_key(cvt_to_seq(derived_cast(policy)),
+                                keys1_first,
+                                keys1_last,
+                                keys2_first,
+                                keys2_last,
+                                items1_first,
+                                items2_first,
+                                keys_result,
+                                items_result,
+                                compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+merge_by_key(execution_policy<Derived> &policy,
+             KeysIt1                    keys1_first,
+             KeysIt1                    keys1_last,
+             KeysIt2                    keys2_first,
+             KeysIt2                    keys2_last,
+             ItemsIt1                   items1_first,
+             ItemsIt2                   items2_first,
+             KeysOutputIt               keys_result,
+             ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type keys_type;
+  return cuda_cub::merge_by_key(policy,
+                                keys1_first,
+                                keys1_last,
+                                keys2_first,
+                                keys2_last,
+                                items1_first,
+                                items2_first,
+                                keys_result,
+                                items_result,
+                                thrust::less<keys_type>());
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/mismatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/mismatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1e2f44d2dff4914ecabcda61605eef317f00c7b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/mismatch.h
@@ -0,0 +1,116 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/pair.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class BinaryPred>
+pair<InputIt1, InputIt2> __host__ __device__
+mismatch(execution_policy<Derived>& policy,
+         InputIt1                   first1,
+         InputIt1                   last1,
+         InputIt2                   first2,
+         BinaryPred                 binary_pred);
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2>
+pair<InputIt1, InputIt2> __host__ __device__
+mismatch(execution_policy<Derived>& policy,
+         InputIt1                   first1,
+         InputIt1                   last1,
+         InputIt2                   first2);
+} // namespace cuda_
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cuda/detail/find.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class BinaryPred>
+pair<InputIt1, InputIt2> __host__ __device__
+mismatch(execution_policy<Derived>& policy,
+         InputIt1                   first1,
+         InputIt1                   last1,
+         InputIt2                   first2,
+         BinaryPred                 binary_pred)
+{
+  typedef transform_pair_of_input_iterators_t<bool,
+                                              InputIt1,
+                                              InputIt2,
+                                              BinaryPred>
+      transform_t;
+
+  transform_t transform_first = transform_t(first1, first2, binary_pred);
+
+  transform_t result = cuda_cub::find_if_not(policy,
+                                          transform_first,
+                                          transform_first + thrust::distance(first1, last1),
+                                          identity());
+
+  return thrust::make_pair(first1 + thrust::distance(transform_first,result),
+                           first2 + thrust::distance(transform_first,result));
+}
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2>
+pair<InputIt1, InputIt2> __host__ __device__
+mismatch(execution_policy<Derived>& policy,
+         InputIt1                   first1,
+         InputIt1                   last1,
+         InputIt2                   first2)
+{
+  typedef typename thrust::iterator_value<InputIt1>::type InputType1;
+  return cuda_cub::mismatch(policy,
+                         first1,
+                         last1,
+                         first2,
+                         equal_to<InputType1>());
+}
+
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par.h
new file mode 100644
index 0000000000000000000000000000000000000000..42c701ca701729853c52f2bc03a3e1452b9cbcc5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par.h
@@ -0,0 +1,258 @@
+/******************************************************************************
+ * Copyright (c) 2016-2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <thrust/detail/allocator_aware_execution_policy.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+#  include <thrust/detail/dependencies_aware_execution_policy.h>
+#endif
+
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived>
+struct execute_on_stream_base : execution_policy<Derived>
+{
+private:
+  cudaStream_t stream;
+
+public:
+  __thrust_exec_check_disable__
+  __host__ __device__
+  execute_on_stream_base(cudaStream_t stream_ = default_stream())
+      : stream(stream_){}
+
+  THRUST_RUNTIME_FUNCTION
+  Derived
+  on(cudaStream_t const &s) const
+  {
+    Derived result = derived_cast(*this);
+    result.stream  = s;
+    return result;
+  }
+
+private:
+  friend __host__ __device__
+  cudaStream_t
+  get_stream(const execute_on_stream_base &exec)
+  {
+    return exec.stream;
+  }
+};
+
+template <class Derived>
+struct execute_on_stream_nosync_base : execution_policy<Derived>
+{
+private:
+  cudaStream_t stream;
+
+public:
+  __host__ __device__
+  execute_on_stream_nosync_base(cudaStream_t stream_ = default_stream())
+      : stream(stream_){}
+
+  THRUST_RUNTIME_FUNCTION
+  Derived
+  on(cudaStream_t const &s) const
+  {
+    Derived result = derived_cast(*this);
+    result.stream  = s;
+    return result;
+  }
+
+private:
+  friend __host__ __device__
+  cudaStream_t
+  get_stream(const execute_on_stream_nosync_base &exec)
+  {
+    return exec.stream;
+  }
+
+  friend __host__ __device__
+  bool
+  must_perform_optional_stream_synchronization(const execute_on_stream_nosync_base &)
+  {
+    return false;
+  }
+};
+
+struct execute_on_stream : execute_on_stream_base<execute_on_stream>
+{
+  typedef execute_on_stream_base<execute_on_stream> base_t;
+
+  __host__ __device__
+  execute_on_stream() : base_t(){};
+  __host__ __device__
+  execute_on_stream(cudaStream_t stream) 
+  : base_t(stream){};
+};
+
+struct execute_on_stream_nosync : execute_on_stream_nosync_base<execute_on_stream_nosync>
+{
+  typedef execute_on_stream_nosync_base<execute_on_stream_nosync> base_t;
+
+  __host__ __device__
+  execute_on_stream_nosync() : base_t(){};
+  __host__ __device__
+  execute_on_stream_nosync(cudaStream_t stream) 
+  : base_t(stream){};
+};
+
+
+struct par_t : execution_policy<par_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    execute_on_stream_base>
+#if THRUST_CPP_DIALECT >= 2011
+, thrust::detail::dependencies_aware_execution_policy<
+    execute_on_stream_base>
+#endif
+{
+  typedef execution_policy<par_t> base_t;
+
+  __host__ __device__
+  constexpr par_t() : base_t() {}
+
+  typedef execute_on_stream stream_attachment_type;
+
+  THRUST_RUNTIME_FUNCTION
+  stream_attachment_type
+  on(cudaStream_t const &stream) const
+  {
+    return execute_on_stream(stream);
+  }
+};
+
+struct par_nosync_t : execution_policy<par_nosync_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    execute_on_stream_nosync_base>
+#if THRUST_CPP_DIALECT >= 2011
+, thrust::detail::dependencies_aware_execution_policy<
+    execute_on_stream_nosync_base>
+#endif
+{
+  typedef execution_policy<par_nosync_t> base_t;
+
+  __host__ __device__
+  constexpr par_nosync_t() : base_t() {}
+
+  typedef execute_on_stream_nosync stream_attachment_type;
+
+  THRUST_RUNTIME_FUNCTION
+  stream_attachment_type
+  on(cudaStream_t const &stream) const
+  {
+    return execute_on_stream_nosync(stream);
+  }
+
+private:
+  //this function is defined to allow non-blocking calls on the default_stream() with thrust::cuda::par_nosync
+  //without explicitly using thrust::cuda::par_nosync.on(default_stream())
+  friend __host__ __device__
+  bool
+  must_perform_optional_stream_synchronization(const par_nosync_t &)
+  {
+    return false;
+  }
+};
+
+THRUST_INLINE_CONSTANT par_t par;
+
+/*! \p thrust::cuda::par_nosync is a parallel execution policy targeting Thrust's CUDA device backend.
+ *  Similar to \p thrust::cuda::par it allows execution of Thrust algorithms in a specific CUDA stream.
+ *
+ *  \p thrust::cuda::par_nosync indicates that an algorithm is free to avoid any synchronization of the 
+ *  associated stream that is not strictly required for correctness. Additionally, algorithms may return
+ *  before the corresponding kernels are completed, similar to asynchronous kernel launches via <<< >>> syntax.
+ *  The user must take care to perform explicit synchronization if necessary.
+ *  
+ *  The following code snippet demonstrates how to use \p thrust::cuda::par_nosync :
+ *
+ *  \code
+ *    #include <thrust/device_vector.h>
+ *    #include <thrust/for_each.h>
+ *    #include <thrust/execution_policy.h>
+ *
+ *    struct IncFunctor{
+ *        __host__ __device__
+ *        void operator()(std::size_t& x){ x = x + 1; };
+ *    };
+ *
+ *    int main(){
+ *        std::size_t N = 1000000;
+ *        thrust::device_vector<std::size_t> d_vec(N);
+ *
+ *        cudaStream_t stream;
+ *        cudaStreamCreate(&stream);
+ *        auto nosync_policy = thrust::cuda::par_nosync.on(stream);
+ *
+ *        thrust::for_each(nosync_policy, d_vec.begin(), d_vec.end(), IncFunctor{});
+ *        thrust::for_each(nosync_policy, d_vec.begin(), d_vec.end(), IncFunctor{});
+ *        thrust::for_each(nosync_policy, d_vec.begin(), d_vec.end(), IncFunctor{});
+ *
+ *        //for_each may return before completion. Could do other cpu work in the meantime
+ *        // ...
+ *
+ *        //Wait for the completion of all for_each kernels
+ *        cudaStreamSynchronize(stream);
+ *
+ *        std::size_t x = thrust::reduce(nosync_policy, d_vec.begin(), d_vec.end());
+ *        //Currently, this synchronization is not necessary. reduce will still perform
+ *        //implicit synchronization to transfer the reduced value to the host to return it.
+ *        cudaStreamSynchronize(stream);
+ *        cudaStreamDestroy(stream);
+ *    }
+ *  \endcode
+ *
+ */
+THRUST_INLINE_CONSTANT par_nosync_t par_nosync;
+}    // namespace cuda_
+
+namespace system {
+namespace cuda {
+  using thrust::cuda_cub::par;
+  using thrust::cuda_cub::par_nosync;
+  namespace detail {
+    using thrust::cuda_cub::par_t;
+    using thrust::cuda_cub::par_nosync_t;
+  }
+} // namesapce cuda
+} // namespace system
+
+namespace cuda {
+using thrust::cuda_cub::par;
+using thrust::cuda_cub::par_nosync;
+} // namespace cuda
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par_to_seq.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par_to_seq.h
new file mode 100644
index 0000000000000000000000000000000000000000..e710f017b6590d9da9908df7e81dd3e533731e1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/par_to_seq.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/seq.h>
+#include <thrust/system/cuda/detail/par.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <int PAR>
+struct has_par : thrust::detail::true_type {};
+
+template <>
+struct has_par<0> : thrust::detail::false_type {};
+
+template<class Policy>
+struct cvt_to_seq_impl
+{
+  typedef thrust::detail::seq_t seq_t;
+
+  static seq_t __host__ __device__
+  doit(Policy&)
+  {
+    return seq_t();
+  }
+};    // cvt_to_seq_impl
+
+#if 0
+template <class Allocator>
+struct cvt_to_seq_impl<
+    thrust::detail::execute_with_allocator<Allocator,
+                                           execute_on_stream_base> >
+{
+  typedef thrust::detail::execute_with_allocator<Allocator,
+                                                 execute_on_stream_base>
+      Policy;
+  typedef thrust::detail::execute_with_allocator<
+      Allocator,
+      thrust::system::detail::sequential::execution_policy>
+      seq_t;
+
+
+  static seq_t __host__ __device__
+  doit(Policy& policy)
+  {
+    return seq_t(policy.m_alloc);
+  }
+};    // specialization of struct cvt_to_seq_impl
+#endif
+
+template <class Policy>
+typename cvt_to_seq_impl<Policy>::seq_t __host__ __device__
+cvt_to_seq(Policy& policy)
+{
+  return cvt_to_seq_impl<Policy>::doit(policy);
+}
+
+} // namespace cuda_
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/parallel_for.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/parallel_for.h
new file mode 100644
index 0000000000000000000000000000000000000000..43c3297aaefb5abb3ba0e9e5153e85f52fa8e168
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/parallel_for.h
@@ -0,0 +1,179 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __parallel_for {
+
+  template <int _BLOCK_THREADS,
+            int _ITEMS_PER_THREAD = 1>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = BLOCK_THREADS * ITEMS_PER_THREAD,
+    };
+  };    // struct PtxPolicy
+
+  template <class Arch, class F>
+  struct Tuning;
+
+  template <class F>
+  struct Tuning<sm30, F>
+  {
+    typedef PtxPolicy<256, 2> type;
+  };
+
+
+  template <class F,
+            class Size>
+  struct ParallelForAgent
+  {
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, F>::type
+    {
+      typedef Tuning<Arch, F> tuning;
+    };
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    enum
+    {
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS
+    };
+
+    template <bool IS_FULL_TILE>
+    static void    THRUST_DEVICE_FUNCTION
+    consume_tile(F    f,
+                 Size tile_base,
+                 int  items_in_tile)
+    {
+#pragma unroll
+      for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+      {
+        Size idx = BLOCK_THREADS * ITEM + threadIdx.x;
+        if (IS_FULL_TILE || idx < items_in_tile)
+          f(tile_base + idx);
+      }
+    }
+
+    THRUST_AGENT_ENTRY(F     f,
+                       Size  num_items,
+                       char * /*shmem*/ )
+    {
+      Size tile_base     = static_cast<Size>(blockIdx.x) * ITEMS_PER_TILE;
+      Size num_remaining = num_items - tile_base;
+      Size items_in_tile = static_cast<Size>(
+          num_remaining < ITEMS_PER_TILE ? num_remaining : ITEMS_PER_TILE);
+
+      if (items_in_tile == ITEMS_PER_TILE)
+      {
+        // full tile
+        consume_tile<true>(f, tile_base, ITEMS_PER_TILE);
+      }
+      else
+      {
+        // partial tile
+        consume_tile<false>(f, tile_base, items_in_tile);
+      }
+    }
+  };    // struct ParallelForEagent
+
+  template <class F,
+            class Size>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  parallel_for(Size         num_items,
+               F            f,
+               cudaStream_t stream)
+  {
+    if (num_items == 0)
+      return cudaSuccess;
+    using core::AgentLauncher;
+    using core::AgentPlan;
+
+    typedef AgentLauncher<ParallelForAgent<F, Size> > parallel_for_agent;
+    AgentPlan parallel_for_plan = parallel_for_agent::get_plan(stream);
+
+    parallel_for_agent pfa(parallel_for_plan, num_items, stream, "transform::agent");
+    pfa.launch(f, num_items);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    return cudaSuccess;
+  }
+}    // __parallel_for
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class F,
+          class Size>
+void __host__ __device__
+parallel_for(execution_policy<Derived> &policy,
+             F                          f,
+             Size                       count)
+{
+  if (count == 0)
+  {
+    return;
+  }
+
+  // clang-format off
+  THRUST_CDP_DISPATCH(
+    (cudaStream_t stream = cuda_cub::stream(policy);
+     cudaError_t  status = __parallel_for::parallel_for(count, f, stream);
+     cuda_cub::throw_on_error(status, "parallel_for failed");
+     status = cuda_cub::synchronize_optional(policy);
+     cuda_cub::throw_on_error(status, "parallel_for: failed to synchronize");),
+    // CDP sequential impl:
+    (for (Size idx = 0; idx != count; ++idx)
+     {
+       f(idx);
+     }
+  ));
+  // clang-format on
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/partition.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/partition.h
new file mode 100644
index 0000000000000000000000000000000000000000..fad75eb0d835d258328e28b2066c7715a382cbd7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/partition.h
@@ -0,0 +1,1088 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/pair.h>
+#include <thrust/partition.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/find.h>
+#include <thrust/system/cuda/detail/reverse.h>
+#include <thrust/system/cuda/detail/uninitialized_copy.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/agent/single_pass_scan_operators.cuh> // cub::ScanTileState
+#include <cub/block/block_scan.cuh>
+#include <cub/device/device_partition.cuh>
+#include <cub/util_device.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __partition {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS      = _BLOCK_THREADS,
+      ITEMS_PER_THREAD   = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE     = _BLOCK_THREADS * _ITEMS_PER_THREAD
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class, class>
+  struct Tuning;
+
+  template<class T>
+  struct Tuning<sm35, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 10,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(1, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<350>
+
+  template<class T>
+  struct Tuning<sm30, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = CUB_MIN(NOMINAL_4B_ITEMS_PER_THREAD, CUB_MAX(3, (NOMINAL_4B_ITEMS_PER_THREAD * 4 / sizeof(T)))),
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning<300>
+
+  template<int T>
+  struct __tag{};
+
+
+  struct no_stencil_tag_    {};
+  struct single_output_tag_
+  {
+    template<class T>
+    THRUST_DEVICE_FUNCTION T const& operator=(T const& t) const { return t; }
+  };
+
+  typedef no_stencil_tag_* no_stencil_tag;
+  typedef single_output_tag_* single_output_tag;;
+
+  template <class ItemsIt,
+            class StencilIt,
+            class SelectedOutIt,
+            class RejectedOutIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutIt>
+  struct PartitionAgent
+  {
+    typedef typename iterator_traits<ItemsIt>::value_type   item_type;
+    typedef typename iterator_traits<StencilIt>::value_type stencil_type;
+
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, item_type>::type
+    {
+      typedef Tuning<Arch,item_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt>::type   ItemsLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, StencilIt>::type StencilLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt>::type   BlockLoadItems;
+      typedef typename core::BlockLoad<PtxPlan, StencilLoadIt>::type BlockLoadStencil;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage          scan;
+          typename TilePrefixCallback::TempStorage prefix;
+        } scan_storage;
+
+        typename BlockLoadItems::TempStorage   load_items;
+        typename BlockLoadStencil::TempStorage load_stencil;
+
+        core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE> raw_exchange;
+      };    // union TempStorage
+    };    // struct PtxPlan
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::ItemsLoadIt        ItemsLoadIt;
+    typedef typename ptx_plan::StencilLoadIt      StencilLoadIt;
+    typedef typename ptx_plan::BlockLoadItems     BlockLoadItems;
+    typedef typename ptx_plan::BlockLoadStencil   BlockLoadStencil;
+    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan          BlockScan;
+    typedef typename ptx_plan::TempStorage        TempStorage;
+
+    enum
+    {
+      SINGLE_OUTPUT    = thrust::detail::is_same<RejectedOutIt, single_output_tag>::value,
+      USE_STENCIL      = !thrust::detail::is_same<StencilIt, no_stencil_tag>::value,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &  temp_storage;
+      ScanTileState &tile_state;
+      ItemsLoadIt    items_glob;
+      StencilLoadIt  stencil_glob;
+      SelectedOutIt  selected_out_glob;
+      RejectedOutIt  rejected_out_glob;
+      Predicate      predicate;
+      Size           num_items;
+
+      //---------------------------------------------------------------------
+      // Utilities
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      scatter(item_type (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  num_tile_items,
+              int  num_tile_selections,
+              Size num_selections_prefix,
+              Size num_rejected_prefix,
+              Size /*num_selections*/)
+      {
+        int tile_num_rejections = num_tile_items - num_tile_selections;
+
+        // Scatter items to shared memory (rejections first)
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int item_idx             = (threadIdx.x * ITEMS_PER_THREAD) + ITEM;
+          int local_selection_idx  = selection_indices[ITEM] - num_selections_prefix;
+          int local_rejection_idx  = item_idx - local_selection_idx;
+          int local_scatter_offset = (selection_flags[ITEM])
+                                         ? tile_num_rejections + local_selection_idx
+                                         : local_rejection_idx;
+
+          temp_storage.raw_exchange[local_scatter_offset] = items[ITEM];
+        }
+
+        core::sync_threadblock();
+
+        // Gather items from shared memory and scatter to global
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int  item_idx       = (ITEM * BLOCK_THREADS) + threadIdx.x;
+          int  rejection_idx  = item_idx;
+          int  selection_idx  = item_idx - tile_num_rejections;
+          Size scatter_offset = (item_idx < tile_num_rejections)
+                                    ? num_items -
+                                          num_rejected_prefix - rejection_idx - 1
+                                    : num_selections_prefix + selection_idx;
+
+          item_type item = temp_storage.raw_exchange[item_idx];
+
+          if (!IS_LAST_TILE || (item_idx < num_tile_items))
+          {
+            if (SINGLE_OUTPUT || item_idx >= tile_num_rejections)
+            {
+              selected_out_glob[scatter_offset] = item;
+            }
+            else    // if !SINGLE_OUTPUT, scatter rejected items separately
+            {
+              rejected_out_glob[num_items - scatter_offset - 1] = item;
+            }
+          }
+        }
+      }    // func scatter
+
+      //------------------------------------------
+      // specialize predicate on different types
+      //------------------------------------------
+
+      enum ItemStencil
+      {
+        ITEM,
+        STENCIL
+      };
+
+      template <bool TAG, class T>
+      struct wrap_value
+      {
+        T const &              x;
+        THRUST_DEVICE_FUNCTION wrap_value(T const &x) : x(x) {}
+
+        THRUST_DEVICE_FUNCTION T const &operator()() const { return x; };
+      };    // struct wrap_type
+
+      //------- item
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &x,
+                        __tag<false /* USE_STENCIL */>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<ITEM, item_type> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+      //-------- stencil
+
+      template <class T>
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, T> const &x,
+                        __tag<true>)
+      {
+        return predicate(x());
+      }
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, no_stencil_tag_> const &,
+                        __tag<true>)
+      {
+        return false;
+      }
+
+
+      THRUST_DEVICE_FUNCTION bool
+      predicate_wrapper(wrap_value<STENCIL, stencil_type> const &,
+                        __tag<false>)
+      {
+        return false;
+      }
+
+      template <bool IS_LAST_TILE, ItemStencil TYPE, class T>
+      THRUST_DEVICE_FUNCTION void
+      compute_selection_flags(int num_tile_items,
+                              T (&values)[ITEMS_PER_THREAD],
+                              Size (&selection_flags)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Out-of-bounds items are selection_flags
+          selection_flags[ITEM] = 1;
+
+          if (!IS_LAST_TILE ||
+              (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM < num_tile_items))
+          {
+            selection_flags[ITEM] =
+                predicate_wrapper(wrap_value<TYPE, T>(values[ITEM]),
+                                  __tag<USE_STENCIL>());
+          }
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        item_type items_loc[ITEMS_PER_THREAD];
+        Size      selection_flags[ITEMS_PER_THREAD];
+        Size      selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE)
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_glob + tile_base, items_loc, num_tile_items);
+        }
+        else
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_glob + tile_base, items_loc);
+        }
+
+        core::sync_threadblock();
+
+        if (USE_STENCIL)
+        {
+          stencil_type stencil_loc[ITEMS_PER_THREAD];
+
+          if (IS_LAST_TILE)
+          {
+            BlockLoadStencil(temp_storage.load_stencil)
+                .Load(stencil_glob + tile_base, stencil_loc, num_tile_items);
+          }
+          else
+          {
+            BlockLoadStencil(temp_storage.load_stencil)
+                .Load(stencil_glob + tile_base, stencil_loc);
+          }
+
+          compute_selection_flags<IS_LAST_TILE, STENCIL>(num_tile_items,
+                                                         stencil_loc,
+                                                         selection_flags);
+        }
+        else /* Use predicate on items rather then stencil */
+        {
+          compute_selection_flags<IS_LAST_TILE, ITEM>(num_tile_items,
+                                                      items_loc,
+                                                      selection_flags);
+        }
+
+        core::sync_threadblock();
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        Size num_rejected_prefix   = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       temp_storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+          num_rejected_prefix   = tile_base - num_selections_prefix;
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        core::sync_threadblock();
+
+        scatter<IS_LAST_TILE>(items_loc,
+                              selection_flags,
+                              selection_idx,
+                              num_tile_items,
+                              num_tile_selections,
+                              num_selections_prefix,
+                              num_rejected_prefix,
+                              num_selections);
+
+
+        return num_selections;
+      }
+
+
+      template <bool         IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION Size
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &    temp_storage_,
+           ScanTileState &  tile_state_,
+           ItemsLoadIt      items_glob_,
+           StencilLoadIt    stencil_glob_,
+           SelectedOutIt    selected_out_glob_,
+           RejectedOutIt    rejected_out_glob_,
+           Predicate        predicate_,
+           Size             num_items_,
+           int              num_tiles,
+           NumSelectedOutIt num_selected_out)
+          : temp_storage(temp_storage_),
+            tile_state(tile_state_),
+            items_glob(items_glob_),
+            stencil_glob(stencil_glob_),
+            selected_out_glob(selected_out_glob_),
+            rejected_out_glob(rejected_out_glob_),
+            predicate(predicate_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }    //
+    };     //struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ItemsIt          items,
+                       StencilIt        stencil,
+                       SelectedOutIt    selected_out,
+                       RejectedOutIt    rejected_out,
+                       Predicate        predicate,
+                       Size             num_items,
+                       NumSelectedOutIt num_selected_out,
+                       ScanTileState    tile_state,
+                       int              num_tiles,
+                       char *           shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           core::make_load_iterator(ptx_plan(), items),
+           core::make_load_iterator(ptx_plan(), stencil),
+           selected_out,
+           rejected_out,
+           predicate,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  };       // struct PartitionAgent
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char *        /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+
+  }; // struct InitAgent
+
+  template <class ItemsIt,
+            class StencilIt,
+            class SelectedOutIt,
+            class RejectedOutIt,
+            class Predicate,
+            class Size,
+            class NumSelectedOutIt>
+  static cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *           d_temp_storage,
+            size_t &         temp_storage_bytes,
+            ItemsIt          items,
+            StencilIt        stencil,
+            SelectedOutIt    selected_out,
+            RejectedOutIt    rejected_out,
+            Predicate        predicate,
+            NumSelectedOutIt num_selected_out,
+            Size             num_items,
+            cudaStream_t     stream)
+  {
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        PartitionAgent<ItemsIt,
+                       StencilIt,
+                       SelectedOutIt,
+                       RejectedOutIt,
+                       Predicate,
+                       Size,
+                       NumSelectedOutIt> >
+        partition_agent;
+
+    typedef typename partition_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type      init_plan      = init_agent::get_plan();
+    typename get_plan<partition_agent>::type partition_plan = partition_agent::get_plan(stream);
+
+    int tile_size = partition_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_storage = core::vshmem_size(partition_plan.shared_memory_size,
+                                              num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    if (num_items == 0)
+      return status;
+
+    size_t allocation_sizes[2] = {0, vshmem_storage};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+
+    void* allocations[2] = {NULL, NULL};
+    status = cub::AliasTemporaries(d_temp_storage,
+                                                temp_storage_bytes,
+                                                allocations,
+                                                allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status = tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    init_agent ia(init_plan, num_tiles, stream, "partition::init_agent");
+
+    char *vshmem_ptr = vshmem_storage > 0 ? (char *)allocations[1] : NULL;
+
+    partition_agent pa(partition_plan, num_items, stream, vshmem_ptr, "partition::partition_agent");
+
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    pa.launch(items,
+              stencil,
+              selected_out,
+              rejected_out,
+              predicate,
+              num_items,
+              num_selected_out,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+
+  }
+
+  template <typename Derived,
+            typename InputIt,
+            typename StencilIt,
+            typename SelectedOutIt,
+            typename RejectedOutIt,
+            typename Predicate>
+  THRUST_RUNTIME_FUNCTION
+  pair<SelectedOutIt, RejectedOutIt>
+  partition(execution_policy<Derived>& policy,
+            InputIt                    first,
+            InputIt                    last,
+            StencilIt                  stencil,
+            SelectedOutIt              selected_result,
+            RejectedOutIt              rejected_result,
+            Predicate                  predicate)
+  {
+    typedef typename iterator_traits<InputIt>::difference_type size_type;
+
+    size_type    num_items          = static_cast<size_type>(thrust::distance(first, last));
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       selected_result,
+                       rejected_result,
+                       predicate,
+                       reinterpret_cast<size_type*>(NULL),
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "partition failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "partition failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "partition failed on 2nd alias_storage");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       first,
+                       stencil,
+                       selected_result,
+                       rejected_result,
+                       predicate,
+                       d_num_selected_out,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "partition failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "partition failed to synchronize");
+
+    size_type num_selected = 0;
+    if (num_items > 0)
+    {
+      num_selected = get_value(policy, d_num_selected_out);
+    }
+
+    return thrust::make_pair(selected_result + num_selected,
+                             rejected_result + num_items - num_selected);
+  }
+
+  template <typename Derived,
+            typename Iterator,
+            typename StencilIt,
+            typename Predicate>
+  THRUST_RUNTIME_FUNCTION
+  Iterator partition_inplace(execution_policy<Derived>& policy,
+                             Iterator                   first,
+                             Iterator                   last,
+                             StencilIt                  stencil,
+                             Predicate                  predicate)
+  {
+    typedef typename iterator_traits<Iterator>::difference_type size_type;
+    typedef typename iterator_traits<Iterator>::value_type      value_type;
+
+    size_type num_items = thrust::distance(first, last);
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<value_type, Derived> tmp(policy, num_items);
+
+    cuda_cub::uninitialized_copy(policy, first, last, tmp.begin());
+
+    pair<Iterator, single_output_tag> result =
+        partition(policy,
+                  tmp.data().get(),
+                  tmp.data().get() + num_items,
+                  stencil,
+                  first,
+                  single_output_tag(),
+                  predicate);
+
+    size_type num_selected = result.first - first;
+
+    return first + num_selected;
+  }
+}    // namespace __partition
+
+///// copy
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class SelectedOutIt,
+          class RejectedOutIt,
+          class Predicate>
+pair<SelectedOutIt, RejectedOutIt> __host__ __device__
+partition_copy(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               StencilIt                  stencil,
+               SelectedOutIt              selected_result,
+               RejectedOutIt              rejected_result,
+               Predicate                  predicate)
+{
+  auto ret = thrust::make_pair(selected_result, rejected_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __partition::partition(policy,
+                                  first,
+                                  last,
+                                  stencil,
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);),
+    (ret = thrust::partition_copy(cvt_to_seq(derived_cast(policy)),
+                                  first,
+                                  last,
+                                  stencil,
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);));
+  return ret;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class SelectedOutIt,
+          class RejectedOutIt,
+          class Predicate>
+pair<SelectedOutIt, RejectedOutIt> __host__ __device__
+partition_copy(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               SelectedOutIt              selected_result,
+               RejectedOutIt              rejected_result,
+               Predicate                  predicate)
+{
+  auto ret = thrust::make_pair(selected_result, rejected_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __partition::partition(policy,
+                                  first,
+                                  last,
+                                  __partition::no_stencil_tag(),
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);),
+    (ret = thrust::partition_copy(cvt_to_seq(derived_cast(policy)),
+                                  first,
+                                  last,
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);));
+  return ret;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class SelectedOutIt,
+          class RejectedOutIt,
+          class Predicate>
+pair<SelectedOutIt, RejectedOutIt> __host__ __device__
+stable_partition_copy(execution_policy<Derived> &policy,
+                      InputIt                    first,
+                      InputIt                    last,
+                      SelectedOutIt              selected_result,
+                      RejectedOutIt              rejected_result,
+                      Predicate                  predicate)
+{
+  auto ret = thrust::make_pair(selected_result, rejected_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __partition::partition(policy,
+                                  first,
+                                  last,
+                                  __partition::no_stencil_tag(),
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);),
+    (ret = thrust::stable_partition_copy(cvt_to_seq(derived_cast(policy)),
+                                         first,
+                                         last,
+                                         selected_result,
+                                         rejected_result,
+                                         predicate);));
+  return ret;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class SelectedOutIt,
+          class RejectedOutIt,
+          class Predicate>
+pair<SelectedOutIt, RejectedOutIt> __host__ __device__
+stable_partition_copy(execution_policy<Derived> &policy,
+                      InputIt                    first,
+                      InputIt                    last,
+                      StencilIt                  stencil,
+                      SelectedOutIt              selected_result,
+                      RejectedOutIt              rejected_result,
+                      Predicate                  predicate)
+{
+  auto ret = thrust::make_pair(selected_result, rejected_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __partition::partition(policy,
+                                  first,
+                                  last,
+                                  stencil,
+                                  selected_result,
+                                  rejected_result,
+                                  predicate);),
+    (ret = thrust::stable_partition_copy(cvt_to_seq(derived_cast(policy)),
+                                         first,
+                                         last,
+                                         stencil,
+                                         selected_result,
+                                         rejected_result,
+                                         predicate);));
+  return ret;
+}
+
+/// inplace
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class Iterator,
+          class StencilIt,
+          class Predicate>
+Iterator __host__ __device__
+partition(execution_policy<Derived> &policy,
+          Iterator                   first,
+          Iterator                   last,
+          StencilIt                  stencil,
+          Predicate                  predicate)
+{
+  THRUST_CDP_DISPATCH(
+    (last =
+       __partition::partition_inplace(policy, first, last, stencil, predicate);),
+    (last = thrust::partition(cvt_to_seq(derived_cast(policy)),
+                              first,
+                              last,
+                              stencil,
+                              predicate);));
+  return last;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class Iterator,
+          class Predicate>
+Iterator __host__ __device__
+partition(execution_policy<Derived> &policy,
+          Iterator                   first,
+          Iterator                   last,
+          Predicate                  predicate)
+{
+  THRUST_CDP_DISPATCH(
+    (last = __partition::partition_inplace(policy,
+                                           first,
+                                           last,
+                                           __partition::no_stencil_tag(),
+                                           predicate);),
+    (last = thrust::partition(cvt_to_seq(derived_cast(policy)),
+                              first,
+                              last,
+                              predicate);));
+  return last;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class Iterator,
+          class StencilIt,
+          class Predicate>
+Iterator __host__ __device__
+stable_partition(execution_policy<Derived> &policy,
+                 Iterator                   first,
+                 Iterator                   last,
+                 StencilIt                  stencil,
+                 Predicate                  predicate)
+{
+  auto ret = last;
+  THRUST_CDP_DISPATCH(
+    (ret =
+       __partition::partition_inplace(policy, first, last, stencil, predicate);
+
+     /* partition returns rejected values in reverse order
+       so reverse the rejected elements to make it stable */
+     cuda_cub::reverse(policy, ret, last);),
+    (ret = thrust::stable_partition(cvt_to_seq(derived_cast(policy)),
+                                    first,
+                                    last,
+                                    stencil,
+                                    predicate);));
+  return ret;
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class Iterator,
+          class Predicate>
+Iterator __host__ __device__
+stable_partition(execution_policy<Derived> &policy,
+                 Iterator                   first,
+                 Iterator                   last,
+                 Predicate                  predicate)
+{
+  auto ret = last;
+  THRUST_CDP_DISPATCH(
+    (ret = __partition::partition_inplace(policy,
+                                          first,
+                                          last,
+                                          __partition::no_stencil_tag(),
+                                          predicate);
+
+     /* partition returns rejected values in reverse order
+      so reverse the rejected elements to make it stable */
+     cuda_cub::reverse(policy, ret, last);),
+    (ret = thrust::stable_partition(cvt_to_seq(derived_cast(policy)),
+                                    first,
+                                    last,
+                                    predicate);));
+  return ret;
+}
+
+template <class Derived,
+          class ItemsIt,
+          class Predicate>
+bool __host__ __device__
+is_partitioned(execution_policy<Derived> &policy,
+               ItemsIt                    first,
+               ItemsIt                    last,
+               Predicate                  predicate)
+{
+  ItemsIt boundary = cuda_cub::find_if_not(policy, first, last, predicate);
+  ItemsIt end      = cuda_cub::find_if(policy,boundary,last,predicate);
+  return end == last;
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/per_device_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/per_device_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..414ea778813a8f5627858f6a600a00601c5191f4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/per_device_resource.h
@@ -0,0 +1,72 @@
+/******************************************************************************
+ * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <mutex>
+#include <unordered_map>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub
+{
+
+template<typename MR, typename DerivedPolicy>
+__host__
+MR * get_per_device_resource(execution_policy<DerivedPolicy>&)
+{
+    static std::mutex map_lock;
+    static std::unordered_map<int, MR> device_id_to_resource;
+
+    int device_id;
+    thrust::cuda_cub::throw_on_error(cudaGetDevice(&device_id));
+
+    std::lock_guard<std::mutex> lock{map_lock};
+    return &device_id_to_resource[device_id];
+}
+
+}
+
+THRUST_NAMESPACE_END
+
+#endif
+
+#endif
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..41d9075da75d11551c4bcc3ae39dab0422b0fb9a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce.h
@@ -0,0 +1,1073 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/make_unsigned_special.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_reduce.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declare generic reduce
+// to circumvent circular dependency
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename T,
+          typename BinaryFunction>
+T __host__ __device__
+reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+       InputIterator                                               first,
+       InputIterator                                               last,
+       T                                                           init,
+       BinaryFunction                                              binary_op);
+
+namespace cuda_cub {
+
+namespace __reduce {
+
+  template<bool>
+  struct is_true : thrust::detail::false_type {};
+  template<>
+  struct is_true<true> : thrust::detail::true_type {};
+
+  template <int                       _BLOCK_THREADS,
+            int                       _ITEMS_PER_THREAD   = 1,
+            int                       _VECTOR_LOAD_LENGTH = 1,
+            cub::BlockReduceAlgorithm _BLOCK_ALGORITHM    = cub::BLOCK_REDUCE_RAKING,
+            cub::CacheLoadModifier    _LOAD_MODIFIER      = cub::LOAD_DEFAULT,
+            cub::GridMappingStrategy  _GRID_MAPPING       = cub::GRID_MAPPING_DYNAMIC>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS      = _BLOCK_THREADS,
+      ITEMS_PER_THREAD   = _ITEMS_PER_THREAD,
+      VECTOR_LOAD_LENGTH = _VECTOR_LOAD_LENGTH,
+      ITEMS_PER_TILE     = _BLOCK_THREADS * _ITEMS_PER_THREAD
+    };
+
+    static const cub::BlockReduceAlgorithm BLOCK_ALGORITHM = _BLOCK_ALGORITHM;
+    static const cub::CacheLoadModifier    LOAD_MODIFIER   = _LOAD_MODIFIER;
+    static const cub::GridMappingStrategy  GRID_MAPPING    = _GRID_MAPPING;
+  }; // struct PtxPolicy
+
+  template<class,class>
+  struct Tuning;
+
+  template <class T>
+  struct Tuning<sm30, T>
+  {
+    enum
+    {
+      // Relative size of T type to a 4-byte word
+      SCALE_FACTOR_4B = (sizeof(T) + 3) / 4,
+      // Relative size of T type to a 1-byte word
+      SCALE_FACTOR_1B = sizeof(T),
+    };
+
+    typedef PtxPolicy<256,
+                      CUB_MAX(1, 20 / SCALE_FACTOR_4B),
+                      2,
+                      cub::BLOCK_REDUCE_WARP_REDUCTIONS,
+                      cub::LOAD_DEFAULT,
+                      cub::GRID_MAPPING_RAKE>
+        type;
+  }; // Tuning sm30
+
+  template <class T>
+  struct Tuning<sm35, T> : Tuning<sm30,T>
+  {
+    // ReducePolicy1B (GTX Titan: 228.7 GB/s @ 192M 1B items)
+    typedef PtxPolicy<128,
+                      CUB_MAX(1, 24 / Tuning::SCALE_FACTOR_1B),
+                      4,
+                      cub::BLOCK_REDUCE_WARP_REDUCTIONS,
+                      cub::LOAD_LDG,
+                      cub::GRID_MAPPING_DYNAMIC>
+        ReducePolicy1B;
+
+    // ReducePolicy4B types (GTX Titan: 255.1 GB/s @ 48M 4B items)
+    typedef PtxPolicy<256,
+                      CUB_MAX(1, 20 / Tuning::SCALE_FACTOR_4B),
+                      4,
+                      cub::BLOCK_REDUCE_WARP_REDUCTIONS,
+                      cub::LOAD_LDG,
+                      cub::GRID_MAPPING_DYNAMIC>
+        ReducePolicy4B;
+
+    typedef typename thrust::detail::conditional<(sizeof(T) < 4),
+                                                 ReducePolicy1B,
+                                                 ReducePolicy4B>::type type;
+  };    // Tuning sm35
+
+  template <class InputIt,
+            class OutputIt,
+            class T,
+            class Size,
+            class ReductionOp>
+  struct ReduceAgent
+  {
+    typedef typename detail::make_unsigned_special<Size>::type UnsignedSize;
+
+    template<class Arch>
+    struct PtxPlan : Tuning<Arch,T>::type
+    {
+      // we need this type definition to indicate "specialize_plan" metafunction
+      // that this PtxPlan may have specializations for different Arch
+      // via Tuning<Arch,T> type.
+      //
+      typedef Tuning<Arch,T> tuning;
+
+      typedef typename cub::CubVector<T, PtxPlan::VECTOR_LOAD_LENGTH> Vector;
+      typedef typename core::LoadIterator<PtxPlan, InputIt>::type     LoadIt;
+      typedef cub::BlockReduce<T,
+                               PtxPlan::BLOCK_THREADS,
+                               PtxPlan::BLOCK_ALGORITHM,
+                               1,
+                               1,
+                               Arch::ver>
+          BlockReduce;
+
+      typedef cub::CacheModifiedInputIterator<PtxPlan::LOAD_MODIFIER,
+                                              Vector,
+                                              Size>
+          VectorLoadIt;
+
+      struct TempStorage
+      {
+        typename BlockReduce::TempStorage reduce;
+        //
+        Size dequeue_offset;
+      };    // struct TempStorage
+
+
+    }; // struct PtxPlan
+
+    // Reduction need additional information which is not covered in
+    // default core::AgentPlan. We thus inherit from core::AgentPlan
+    // and add additional member fields that are needed.
+    // Other algorithms, e.g. merge, may not need additional information,
+    // and may use AgentPlan directly, instead of defining their own Plan type.
+    //
+    struct Plan : core::AgentPlan
+    {
+      cub::GridMappingStrategy grid_mapping;
+
+      THRUST_RUNTIME_FUNCTION
+      Plan() {}
+
+      template <class P>
+      THRUST_RUNTIME_FUNCTION
+          Plan(P) : core::AgentPlan(P()),
+                    grid_mapping(P::GRID_MAPPING)
+      {
+      }
+    };
+
+    // this specialized PtxPlan for a device-compiled Arch
+    // ptx_plan type *must* only be used from device code
+    // Its use from host code will result in *undefined behaviour*
+    //
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::TempStorage  TempStorage;
+    typedef typename ptx_plan::Vector       Vector;
+    typedef typename ptx_plan::LoadIt       LoadIt;
+    typedef typename ptx_plan::BlockReduce  BlockReduce;
+    typedef typename ptx_plan::VectorLoadIt VectorLoadIt;
+
+    enum
+    {
+      ITEMS_PER_THREAD   = ptx_plan::ITEMS_PER_THREAD,
+      BLOCK_THREADS      = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_TILE     = ptx_plan::ITEMS_PER_TILE,
+      VECTOR_LOAD_LENGTH = ptx_plan::VECTOR_LOAD_LENGTH,
+
+      ATTEMPT_VECTORIZATION = (VECTOR_LOAD_LENGTH > 1) &&
+                              (ITEMS_PER_THREAD % VECTOR_LOAD_LENGTH == 0) &&
+                              thrust::detail::is_pointer<InputIt>::value &&
+                              thrust::detail::is_arithmetic<
+                                  typename thrust::detail::remove_cv<T> >::value
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per thread data
+      //---------------------------------------------------------------------
+
+      TempStorage &storage;
+      InputIt      input_it;
+      LoadIt       load_it;
+      ReductionOp  reduction_op;
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION impl(TempStorage &storage_,
+                                  InputIt      input_it_,
+                                  ReductionOp  reduction_op_)
+          : storage(storage_),
+            input_it(input_it_),
+            load_it(core::make_load_iterator(ptx_plan(), input_it)),
+            reduction_op(reduction_op_) {}
+
+      //---------------------------------------------------------------------
+      // Utility
+      //---------------------------------------------------------------------
+
+
+      // Whether or not the input is aligned with the vector type
+      // (specialized for types we can vectorize)
+      //
+      template <class Iterator>
+      static THRUST_DEVICE_FUNCTION bool
+      is_aligned(Iterator d_in,
+                 thrust::detail::true_type /* can_vectorize */)
+      {
+        return (size_t(d_in) & (sizeof(Vector) - 1)) == 0;
+      }
+
+      // Whether or not the input is aligned with the vector type
+      // (specialized for types we cannot vectorize)
+      //
+      template <class Iterator>
+      static THRUST_DEVICE_FUNCTION bool
+      is_aligned(Iterator,
+                 thrust::detail::false_type /* can_vectorize */)
+      {
+        return false;
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      // Consume a full tile of input (non-vectorized)
+      //
+      template <int IS_FIRST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_tile(T &  thread_aggregate,
+                   Size block_offset,
+                   int  /*valid_items*/,
+                   thrust::detail::true_type /* is_full_tile */,
+                   thrust::detail::false_type /* can_vectorize */)
+      {
+        T items[ITEMS_PER_THREAD];
+
+        // Load items in striped fashion
+        cub::LoadDirectStriped<BLOCK_THREADS>(threadIdx.x,
+                                              load_it + block_offset,
+                                              items);
+
+        // Reduce items within each thread stripe
+        thread_aggregate =
+            (IS_FIRST_TILE) ? cub::internal::ThreadReduce(items, reduction_op)
+                            : cub::internal::ThreadReduce(items, reduction_op,
+                                                          thread_aggregate);
+      }
+
+      // Consume a full tile of input (vectorized)
+      //
+      template <int IS_FIRST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_tile(T &  thread_aggregate,
+                   Size block_offset,
+                   int  /*valid_items*/,
+                   thrust::detail::true_type /* is_full_tile */,
+                   thrust::detail::true_type /* can_vectorize */)
+      {
+        // Alias items as an array of VectorT and load it in striped fashion
+        enum
+        {
+          WORDS = ITEMS_PER_THREAD / VECTOR_LOAD_LENGTH
+        };
+
+        T items[ITEMS_PER_THREAD];
+
+        Vector *vec_items = reinterpret_cast<Vector *>(items);
+
+        // Vector Input iterator wrapper type (for applying cache modifier)
+        T *d_in_unqualified = const_cast<T *>(input_it) +
+                              block_offset +
+                              (threadIdx.x * VECTOR_LOAD_LENGTH);
+        VectorLoadIt vec_load_it(reinterpret_cast<Vector *>(d_in_unqualified));
+
+#pragma unroll
+        for (int i = 0; i < WORDS; ++i)
+        {
+          vec_items[i] = vec_load_it[BLOCK_THREADS * i];
+        }
+
+
+        // Reduce items within each thread stripe
+        thread_aggregate =
+            (IS_FIRST_TILE) ? cub::internal::ThreadReduce(items, reduction_op)
+                            : cub::internal::ThreadReduce(items, reduction_op,
+                                                          thread_aggregate);
+      }
+
+
+      // Consume a partial tile of input
+      //
+      template <int IS_FIRST_TILE, class CAN_VECTORIZE>
+      THRUST_DEVICE_FUNCTION void
+      consume_tile(T &  thread_aggregate,
+                   Size block_offset,
+                   int  valid_items,
+                   thrust::detail::false_type /* is_full_tile */,
+                   CAN_VECTORIZE)
+      {
+        // Partial tile
+        int thread_offset = threadIdx.x;
+
+        // Read first item
+        if ((IS_FIRST_TILE) && (thread_offset < valid_items))
+        {
+          thread_aggregate = load_it[block_offset + thread_offset];
+          thread_offset += BLOCK_THREADS;
+        }
+
+        // Continue reading items (block-striped)
+        while (thread_offset < valid_items)
+        {
+          thread_aggregate = reduction_op(
+              thread_aggregate,
+              thrust::raw_reference_cast(load_it[block_offset + thread_offset]));
+          thread_offset += BLOCK_THREADS;
+        }
+      }
+
+      //---------------------------------------------------------------
+      // Consume a contiguous segment of tiles
+      //---------------------------------------------------------------------
+
+
+      // Reduce a contiguous segment of input tiles
+      //
+      template <class CAN_VECTORIZE>
+      THRUST_DEVICE_FUNCTION T
+      consume_range_impl(Size          block_offset,
+                         Size          block_end,
+                         CAN_VECTORIZE can_vectorize)
+      {
+        T thread_aggregate;
+
+        if (block_offset + ITEMS_PER_TILE > block_end)
+        {
+          // First tile isn't full (not all threads have valid items)
+          int valid_items = block_end - block_offset;
+          consume_tile<true>(thread_aggregate,
+                             block_offset,
+                             valid_items,
+                             thrust::detail::false_type(),
+                             can_vectorize);
+          return BlockReduce(storage.reduce)
+              .Reduce(thread_aggregate, reduction_op, valid_items);
+        }
+
+        // At least one full block
+        consume_tile<true>(thread_aggregate,
+                           block_offset,
+                           ITEMS_PER_TILE,
+                           thrust::detail::true_type(),
+                           can_vectorize);
+        block_offset += ITEMS_PER_TILE;
+
+        // Consume subsequent full tiles of input
+        while (block_offset + ITEMS_PER_TILE <= block_end)
+        {
+          consume_tile<false>(thread_aggregate,
+                              block_offset,
+                              ITEMS_PER_TILE,
+                              thrust::detail::true_type(),
+                              can_vectorize);
+          block_offset += ITEMS_PER_TILE;
+        }
+
+        // Consume a partially-full tile
+        if (block_offset < block_end)
+        {
+          int valid_items = block_end - block_offset;
+          consume_tile<false>(thread_aggregate,
+                              block_offset,
+                              valid_items,
+                              thrust::detail::false_type(),
+                              can_vectorize);
+        }
+
+        // Compute block-wide reduction (all threads have valid items)
+        return BlockReduce(storage.reduce)
+            .Reduce(thread_aggregate, reduction_op);
+      }
+
+      // Reduce a contiguous segment of input tiles
+      //
+      THRUST_DEVICE_FUNCTION T consume_range(Size block_offset,
+                                             Size block_end)
+      {
+        typedef is_true<ATTEMPT_VECTORIZATION>          attempt_vec;
+        typedef is_true<true && ATTEMPT_VECTORIZATION>  path_a;
+        typedef is_true<false && ATTEMPT_VECTORIZATION> path_b;
+
+        return is_aligned(input_it + block_offset, attempt_vec())
+                   ? consume_range_impl(block_offset, block_end, path_a())
+                   : consume_range_impl(block_offset, block_end, path_b());
+      }
+
+      // Reduce a contiguous segment of input tiles
+      //
+      THRUST_DEVICE_FUNCTION T
+      consume_tiles(Size /*num_items*/,
+                    cub::GridEvenShare<Size> &even_share,
+                    cub::GridQueue<UnsignedSize> & /*queue*/,
+                    thrust::detail::integral_constant<cub::GridMappingStrategy, cub::GRID_MAPPING_RAKE> /*is_rake*/)
+      {
+        typedef is_true<ATTEMPT_VECTORIZATION>          attempt_vec;
+        typedef is_true<true && ATTEMPT_VECTORIZATION>  path_a;
+        typedef is_true<false && ATTEMPT_VECTORIZATION> path_b;
+
+        // Initialize even-share descriptor for this thread block
+        even_share
+            .template BlockInit<ITEMS_PER_TILE, cub::GRID_MAPPING_RAKE>();
+
+        return is_aligned(input_it, attempt_vec())
+                   ? consume_range_impl(even_share.block_offset,
+                                        even_share.block_end,
+                                        path_a())
+                   : consume_range_impl(even_share.block_offset,
+                                        even_share.block_end,
+                                        path_b());
+      }
+
+
+      //---------------------------------------------------------------------
+      // Dynamically consume tiles
+      //---------------------------------------------------------------------
+
+      // Dequeue and reduce tiles of items as part of a inter-block reduction
+      //
+      template <class CAN_VECTORIZE>
+      THRUST_DEVICE_FUNCTION T
+      consume_tiles_impl(Size                         num_items,
+                         cub::GridQueue<UnsignedSize> queue,
+                         CAN_VECTORIZE                can_vectorize)
+      {
+        using core::sync_threadblock;
+
+        // We give each thread block at least one tile of input.
+        T    thread_aggregate;
+        Size block_offset    = blockIdx.x * ITEMS_PER_TILE;
+        Size even_share_base = gridDim.x * ITEMS_PER_TILE;
+
+        if (block_offset + ITEMS_PER_TILE > num_items)
+        {
+          // First tile isn't full (not all threads have valid items)
+          int valid_items = num_items - block_offset;
+          consume_tile<true>(thread_aggregate,
+                             block_offset,
+                             valid_items,
+                             thrust::detail::false_type(),
+                             can_vectorize);
+          return BlockReduce(storage.reduce)
+              .Reduce(thread_aggregate, reduction_op, valid_items);
+        }
+
+        // Consume first full tile of input
+        consume_tile<true>(thread_aggregate,
+                           block_offset,
+                           ITEMS_PER_TILE,
+                           thrust::detail::true_type(),
+                           can_vectorize);
+
+        if (num_items > even_share_base)
+        {
+          // Dequeue a tile of items
+          if (threadIdx.x == 0)
+            storage.dequeue_offset = queue.Drain(ITEMS_PER_TILE) +
+                                     even_share_base;
+
+          sync_threadblock();
+
+          // Grab tile offset and check if we're done with full tiles
+          block_offset = storage.dequeue_offset;
+
+          // Consume more full tiles
+          while (block_offset + ITEMS_PER_TILE <= num_items)
+          {
+            consume_tile<false>(thread_aggregate,
+                                block_offset,
+                                ITEMS_PER_TILE,
+                                thrust::detail::true_type(),
+                                can_vectorize);
+
+            sync_threadblock();
+
+            // Dequeue a tile of items
+            if (threadIdx.x == 0)
+              storage.dequeue_offset = queue.Drain(ITEMS_PER_TILE) +
+                                       even_share_base;
+
+            sync_threadblock();
+
+            // Grab tile offset and check if we're done with full tiles
+            block_offset = storage.dequeue_offset;
+          }
+
+          // Consume partial tile
+          if (block_offset < num_items)
+          {
+            int valid_items = num_items - block_offset;
+            consume_tile<false>(thread_aggregate,
+                                block_offset,
+                                valid_items,
+                                thrust::detail::false_type(),
+                                can_vectorize);
+          }
+        }
+
+        // Compute block-wide reduction (all threads have valid items)
+        return BlockReduce(storage.reduce)
+            .Reduce(thread_aggregate, reduction_op);
+      }
+
+
+      // Dequeue and reduce tiles of items as part of a inter-block reduction
+      //
+      THRUST_DEVICE_FUNCTION T
+      consume_tiles(
+          Size                              num_items,
+          cub::GridEvenShare<Size> &/*even_share*/,
+          cub::GridQueue<UnsignedSize> &    queue,
+          thrust::detail::integral_constant<cub::GridMappingStrategy, cub::GRID_MAPPING_DYNAMIC>)
+      {
+        typedef is_true<ATTEMPT_VECTORIZATION>         attempt_vec;
+        typedef is_true<true && ATTEMPT_VECTORIZATION> path_a;
+        typedef is_true<false && ATTEMPT_VECTORIZATION> path_b;
+
+        return is_aligned(input_it, attempt_vec())
+                   ? consume_tiles_impl(num_items, queue, path_a())
+                   : consume_tiles_impl(num_items, queue, path_b());
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry points
+    //---------------------------------------------------------------------
+
+    // single tile reduce entry point
+    //
+    THRUST_AGENT_ENTRY(InputIt     input_it,
+                       OutputIt    output_it,
+                       Size        num_items,
+                       ReductionOp reduction_op,
+                       char *      shmem)
+    {
+      TempStorage& storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      if (num_items == 0)
+      {
+        return;
+      }
+
+      T block_aggregate =
+          impl(storage, input_it, reduction_op).consume_range((Size)0, num_items);
+
+      if (threadIdx.x == 0)
+        *output_it = block_aggregate;
+    }
+
+    // single tile reduce entry point
+    //
+    THRUST_AGENT_ENTRY(InputIt     input_it,
+                       OutputIt    output_it,
+                       Size        num_items,
+                       ReductionOp reduction_op,
+                       T           init,
+                       char *      shmem)
+    {
+      TempStorage& storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      if (num_items == 0)
+      {
+        if (threadIdx.x == 0)
+          *output_it = init;
+        return;
+      }
+
+      T block_aggregate =
+          impl(storage, input_it, reduction_op).consume_range((Size)0, num_items);
+
+      if (threadIdx.x == 0)
+        *output_it = reduction_op(init, block_aggregate);
+    }
+
+    THRUST_AGENT_ENTRY(InputIt                          input_it,
+                       OutputIt                         output_it,
+                       Size                             num_items,
+                       cub::GridEvenShare<Size> even_share,
+                       cub::GridQueue<UnsignedSize>     queue,
+                       ReductionOp                      reduction_op,
+                       char *                           shmem)
+    {
+      TempStorage& storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      typedef thrust::detail::integral_constant<cub::GridMappingStrategy, ptx_plan::GRID_MAPPING> grid_mapping;
+
+      T block_aggregate =
+          impl(storage, input_it, reduction_op)
+              .consume_tiles(num_items, even_share, queue, grid_mapping());
+
+      if (threadIdx.x == 0)
+        output_it[blockIdx.x] = block_aggregate;
+    }
+  };    // struct ReduceAgent
+
+  template<class Size>
+  struct DrainAgent
+  {
+    typedef typename detail::make_unsigned_special<Size>::type UnsignedSize;
+
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<1> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(cub::GridQueue<UnsignedSize> grid_queue,
+                       Size                         num_items,
+                       char * /*shmem*/)
+    {
+      grid_queue.FillAndResetDrain(num_items);
+    }
+  };    // struct DrainAgent;
+
+
+  template <class InputIt,
+            class OutputIt,
+            class Size,
+            class ReductionOp,
+            class T>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *       d_temp_storage,
+            size_t &     temp_storage_bytes,
+            InputIt      input_it,
+            Size         num_items,
+            T            init,
+            ReductionOp  reduction_op,
+            OutputIt     output_it,
+            cudaStream_t stream)
+  {
+    using core::AgentPlan;
+    using core::AgentLauncher;
+    using core::get_agent_plan;
+    using core::cuda_optional;
+
+    typedef typename detail::make_unsigned_special<Size>::type UnsignedSize;
+
+    if (num_items == 0)
+      return cudaErrorNotSupported;
+
+    typedef AgentLauncher<
+        ReduceAgent<InputIt, OutputIt, T, Size, ReductionOp> >
+        reduce_agent;
+
+    typename reduce_agent::Plan reduce_plan = reduce_agent::get_plan(stream);
+
+    cudaError_t status = cudaSuccess;
+
+
+    if (num_items <= reduce_plan.items_per_tile)
+    {
+      size_t vshmem_size = core::vshmem_size(reduce_plan.shared_memory_size, 1);
+
+      // small, single tile size
+      if (d_temp_storage == NULL)
+      {
+        temp_storage_bytes = max<size_t>(1, vshmem_size);
+        return status;
+      }
+      char *vshmem_ptr = vshmem_size > 0 ? (char*)d_temp_storage : NULL;
+
+      reduce_agent ra(reduce_plan, num_items, stream, vshmem_ptr, "reduce_agent: single_tile only");
+      ra.launch(input_it, output_it, num_items, reduction_op, init);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    }
+    else
+    {
+      // regular size
+      cuda_optional<int> sm_count = core::get_sm_count();
+      CUDA_CUB_RET_IF_FAIL(sm_count.status());
+
+      // reduction will not use more cta counts than requested
+      cuda_optional<int> max_blocks_per_sm =
+          reduce_agent::
+              template get_max_blocks_per_sm<InputIt,
+                                             OutputIt,
+                                             Size,
+                                             cub::GridEvenShare<Size>,
+                                             cub::GridQueue<UnsignedSize>,
+                                             ReductionOp>(reduce_plan);
+      CUDA_CUB_RET_IF_FAIL(max_blocks_per_sm.status());
+
+
+
+      int reduce_device_occupancy = (int)max_blocks_per_sm * sm_count;
+
+      int sm_oversubscription = 5;
+      int max_blocks          = reduce_device_occupancy * sm_oversubscription;
+
+      cub::GridEvenShare<Size> even_share;
+      even_share.DispatchInit(static_cast<int>(num_items), max_blocks,
+                              reduce_plan.items_per_tile);
+
+      // we will launch at most "max_blocks" blocks in a grid
+      // so preallocate virtual shared memory storage for this if required
+      //
+      size_t vshmem_size = core::vshmem_size(reduce_plan.shared_memory_size,
+                                             max_blocks);
+
+      // Temporary storage allocation requirements
+      void * allocations[3] = {NULL, NULL, NULL};
+      size_t allocation_sizes[3] =
+          {
+              max_blocks * sizeof(T),                            // bytes needed for privatized block reductions
+              cub::GridQueue<UnsignedSize>::AllocationSize(),    // bytes needed for grid queue descriptor0
+              vshmem_size                                        // size of virtualized shared memory storage
+          };
+      status = cub::AliasTemporaries(d_temp_storage,
+                                     temp_storage_bytes,
+                                     allocations,
+                                     allocation_sizes);
+      CUDA_CUB_RET_IF_FAIL(status);
+      if (d_temp_storage == NULL)
+      {
+        return status;
+      }
+
+      T *d_block_reductions = (T*) allocations[0];
+      cub::GridQueue<UnsignedSize> queue(allocations[1]);
+      char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[2] : NULL;
+
+
+      // Get grid size for device_reduce_sweep_kernel
+      int reduce_grid_size = 0;
+      if (reduce_plan.grid_mapping == cub::GRID_MAPPING_RAKE)
+      {
+        // Work is distributed evenly
+        reduce_grid_size = even_share.grid_size;
+      }
+      else if (reduce_plan.grid_mapping == cub::GRID_MAPPING_DYNAMIC)
+      {
+        // Work is distributed dynamically
+        size_t num_tiles = cub::DivideAndRoundUp(num_items, reduce_plan.items_per_tile);
+
+        // if not enough to fill the device with threadblocks
+        // then fill the device with threadblocks
+        reduce_grid_size = static_cast<int>((min)(num_tiles, static_cast<size_t>(reduce_device_occupancy)));
+
+        typedef AgentLauncher<DrainAgent<Size> > drain_agent;
+        AgentPlan drain_plan = drain_agent::get_plan();
+        drain_plan.grid_size = 1;
+        drain_agent da(drain_plan, stream, "__reduce::drain_agent");
+        da.launch(queue, num_items);
+        CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+      }
+      else
+      {
+        CUDA_CUB_RET_IF_FAIL(cudaErrorNotSupported);
+      }
+
+      reduce_plan.grid_size = reduce_grid_size;
+      reduce_agent ra(reduce_plan, stream, vshmem_ptr, "reduce_agent: regular size reduce");
+      ra.launch(input_it,
+                d_block_reductions,
+                num_items,
+                even_share,
+                queue,
+                reduction_op);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+
+      typedef AgentLauncher<
+        ReduceAgent<T*, OutputIt, T, Size, ReductionOp> >
+        reduce_agent_single;
+
+      reduce_plan.grid_size = 1;
+      reduce_agent_single ra1(reduce_plan, stream, vshmem_ptr, "reduce_agent: single tile reduce");
+
+      ra1.launch(d_block_reductions, output_it, reduce_grid_size, reduction_op, init);
+      CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    }
+
+    return status;
+  }    // func doit_step
+
+
+  template <typename Derived,
+            typename InputIt,
+            typename Size,
+            typename T,
+            typename BinaryOp>
+  THRUST_RUNTIME_FUNCTION
+  T reduce(execution_policy<Derived>& policy,
+           InputIt                    first,
+           Size                       num_items,
+           T                          init,
+           BinaryOp                   binary_op)
+  {
+    if (num_items == 0)
+      return init;
+
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       first,
+                       num_items,
+                       init,
+                       binary_op,
+                       reinterpret_cast<T*>(NULL),
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(T*), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 2nd alias_storage");
+
+    T* d_result = thrust::detail::aligned_reinterpret_cast<T*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       first,
+                       num_items,
+                       init,
+                       binary_op,
+                       d_result,
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "reduce failed to synchronize");
+
+    T result = cuda_cub::get_value(policy, d_result);
+
+    return result;
+  }
+}    // namespace __reduce
+
+namespace detail {
+
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename T,
+          typename BinaryOp>
+THRUST_RUNTIME_FUNCTION
+T reduce_n_impl(execution_policy<Derived>& policy,
+                InputIt                    first,
+                Size                       num_items,
+                T                          init,
+                BinaryOp                   binary_op)
+{
+  cudaStream_t stream = cuda_cub::stream(policy);
+  cudaError_t status;
+
+  // Determine temporary device storage requirements.
+
+  size_t tmp_size = 0;
+
+  THRUST_INDEX_TYPE_DISPATCH(status,
+    cub::DeviceReduce::Reduce,
+    num_items,
+    (NULL, tmp_size, first, reinterpret_cast<T*>(NULL),
+        num_items_fixed, binary_op, init, stream));
+  cuda_cub::throw_on_error(status, "after reduction step 1");
+
+  // Allocate temporary storage.
+
+  thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+    tmp(policy, sizeof(T) + tmp_size);
+
+  // Run reduction.
+
+  // `tmp.begin()` yields a `normal_iterator`, which dereferences to a
+  // `reference`, which has an `operator&` that returns a `pointer`, which
+  // has a `.get` method that returns a raw pointer, which we can (finally)
+  // `static_cast` to `void*`.
+  //
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  T* ret_ptr = thrust::detail::aligned_reinterpret_cast<T*>(tmp.data().get());
+  void* tmp_ptr = static_cast<void*>((tmp.data() + sizeof(T)).get());
+  THRUST_INDEX_TYPE_DISPATCH(status,
+    cub::DeviceReduce::Reduce,
+    num_items,
+    (tmp_ptr, tmp_size, first, ret_ptr,
+        num_items_fixed, binary_op, init, stream));
+  cuda_cub::throw_on_error(status, "after reduction step 2");
+
+  // Synchronize the stream and get the value.
+
+  status = cuda_cub::synchronize(policy);
+  cuda_cub::throw_on_error(status, "reduce failed to synchronize");
+
+  // `tmp.begin()` yields a `normal_iterator`, which dereferences to a
+  // `reference`, which has an `operator&` that returns a `pointer`, which
+  // has a `.get` method that returns a raw pointer, which we can (finally)
+  // `static_cast` to `void*`.
+  //
+  // The array was dynamically allocated, so we assume that it's suitably
+  // aligned for any type of data. `malloc`/`cudaMalloc`/`new`/`std::allocator`
+  // make this guarantee.
+  return thrust::cuda_cub::get_value(policy,
+    thrust::detail::aligned_reinterpret_cast<T*>(tmp.data().get()));
+}
+
+} // namespace detail
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename T,
+          typename BinaryOp>
+__host__ __device__
+T reduce_n(execution_policy<Derived>& policy,
+           InputIt                    first,
+           Size                       num_items,
+           T                          init,
+           BinaryOp                   binary_op)
+{
+  THRUST_CDP_DISPATCH((init =
+                         thrust::cuda_cub::detail::reduce_n_impl(policy,
+                                                                 first,
+                                                                 num_items,
+                                                                 init,
+                                                                 binary_op);),
+                      (init = thrust::reduce(cvt_to_seq(derived_cast(policy)),
+                                             first,
+                                             first + num_items,
+                                             init,
+                                             binary_op);));
+  return init;
+}
+
+template <class Derived, class InputIt, class T, class BinaryOp>
+__host__ __device__
+T reduce(execution_policy<Derived> &policy,
+         InputIt                    first,
+         InputIt                    last,
+         T                          init,
+         BinaryOp                   binary_op)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  // FIXME: Check for RA iterator.
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  return cuda_cub::reduce_n(policy, first, num_items, init, binary_op);
+}
+
+template <class Derived,
+          class InputIt,
+          class T>
+__host__ __device__
+T reduce(execution_policy<Derived> &policy,
+         InputIt                    first,
+         InputIt                    last,
+         T                          init)
+{
+  return cuda_cub::reduce(policy, first, last, init, plus<T>());
+}
+
+template <class Derived,
+          class InputIt>
+__host__ __device__
+typename iterator_traits<InputIt>::value_type
+reduce(execution_policy<Derived> &policy,
+       InputIt                    first,
+       InputIt                    last)
+{
+  typedef typename iterator_traits<InputIt>::value_type value_type;
+  return cuda_cub::reduce(policy, first, last, value_type(0));
+}
+
+
+} // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/reduce.h>
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..2933d062acd9f174e2a38bc7e20b5b648e9882bb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reduce_by_key.h
@@ -0,0 +1,1209 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_reduce.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename BinaryPredicate>
+__host__ __device__ thrust::pair<OutputIterator1, OutputIterator2>
+reduce_by_key(
+    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);
+
+namespace cuda_cub {
+
+namespace __reduce_by_key {
+
+  template<bool> struct is_true : thrust::detail::false_type {};
+  template<> struct is_true<true> : thrust::detail::true_type {};
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_DEFAULT,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = BLOCK_THREADS * ITEMS_PER_THREAD
+    };
+
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template <class Arch, class Key, class Value>
+  struct Tuning;
+
+  template <class Key, class Value>
+  struct Tuning<sm30, Key, Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 6,
+
+      ITEMS_PER_THREAD = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm30
+
+  template<class Key, class Value>
+  struct Tuning<sm35,Key,Value> : Tuning<sm30,Key,Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 6,
+
+      ITEMS_PER_THREAD =
+          (MAX_INPUT_BYTES <= 8)
+              ? 6
+              : mpl::min<
+                    int,
+                    NOMINAL_4B_ITEMS_PER_THREAD,
+                    mpl::max<
+                        int,
+                        1,
+                        ((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+                         COMBINED_INPUT_BYTES - 1) /
+                            COMBINED_INPUT_BYTES>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm35
+
+  template<class Key, class Value>
+  struct Tuning<sm52,Key,Value> : Tuning<sm30,Key,Value>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES      = mpl::max<size_t, sizeof(Key), sizeof(Value)>::value,
+      COMBINED_INPUT_BYTES = sizeof(Key) + sizeof(Value),
+
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+
+      ITEMS_PER_THREAD =
+          (MAX_INPUT_BYTES <= 8)
+              ? 9
+              : mpl::min<
+                    int,
+                    NOMINAL_4B_ITEMS_PER_THREAD,
+                    mpl::max<
+                        int,
+                        1,
+                        ((NOMINAL_4B_ITEMS_PER_THREAD * 8) +
+                         COMBINED_INPUT_BYTES - 1) /
+                            COMBINED_INPUT_BYTES>::value>::value,
+    };
+
+    typedef PtxPolicy<256,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning sm52
+
+  template <class KeysInputIt,
+            class ValuesInputIt,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class EqualityOp,
+            class ReductionOp,
+            class NumRunsOutputIt,
+            class Size>
+  struct ReduceByKeyAgent
+  {
+    typedef typename iterator_traits<KeysInputIt>::value_type   key_type;
+    typedef typename iterator_traits<ValuesInputIt>::value_type value_type;
+    typedef Size                                                size_type;
+
+    typedef cub::KeyValuePair<size_type, value_type> size_value_pair_t;
+    typedef cub::KeyValuePair<key_type, value_type>  key_value_pair_t;
+
+    typedef cub::ReduceByKeyScanTileState<value_type, size_type> ScanTileState;
+    typedef cub::ReduceBySegmentOp<ReductionOp> ReduceBySegmentOp;
+
+    template<class Arch>
+    struct PtxPlan : Tuning<Arch,key_type, value_type>::type
+    {
+      typedef Tuning<Arch, key_type, value_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeysInputIt>::type    KeysLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, ValuesInputIt>::type  ValuesLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt>::type   BlockLoadKeys;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt>::type BlockLoadValues;
+
+      typedef cub::BlockDiscontinuity<key_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityKeys;
+
+      typedef cub::TilePrefixCallbackOp<size_value_pair_t,
+                                        ReduceBySegmentOp,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<size_value_pair_t,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage              scan;
+          typename TilePrefixCallback::TempStorage     prefix;
+          typename BlockDiscontinuityKeys::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadKeys::TempStorage   load_keys;
+        typename BlockLoadValues::TempStorage load_values;
+
+        core::uninitialized_array<key_value_pair_t, PtxPlan::ITEMS_PER_TILE + 1>
+          raw_exchange;
+      };    // union TempStorage
+    };  // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeysLoadIt             KeysLoadIt;
+    typedef typename ptx_plan::ValuesLoadIt           ValuesLoadIt;
+    typedef typename ptx_plan::BlockLoadKeys          BlockLoadKeys;
+    typedef typename ptx_plan::BlockLoadValues        BlockLoadValues;
+    typedef typename ptx_plan::BlockDiscontinuityKeys BlockDiscontinuityKeys;
+    typedef typename ptx_plan::TilePrefixCallback     TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan              BlockScan;
+    typedef typename ptx_plan::TempStorage            TempStorage;
+
+    enum
+    {
+      BLOCK_THREADS     = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD  = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE    = ptx_plan::ITEMS_PER_TILE,
+      TWO_PHASE_SCATTER = (ITEMS_PER_THREAD > 1),
+
+      // Whether or not the scan operation has a zero-valued identity value
+      // (true if we're performing addition on a primitive type)
+      HAS_IDENTITY_ZERO = thrust::detail::is_same<ReductionOp,
+                                                  plus<value_type> >::value &&
+                          thrust::detail::is_arithmetic<value_type>::value
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      storage;
+      KeysLoadIt                         keys_load_it;
+      ValuesLoadIt                       values_load_it;
+      KeysOutputIt                       keys_output_it;
+      ValuesOutputIt                     values_output_it;
+      NumRunsOutputIt                    num_runs_output_it;
+      cub::InequalityWrapper<EqualityOp> inequality_op;
+      ReduceBySegmentOp                  scan_op;
+
+      //---------------------------------------------------------------------
+      // Block scan utility methods
+      //---------------------------------------------------------------------
+
+      // Scan with identity (first tile)
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t &tile_aggregate,
+                thrust::detail::true_type /* has_identity */)
+      {
+        size_value_pair_t identity;
+        identity.value = 0;
+        identity.key   = 0;
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items, scan_items, identity, scan_op, tile_aggregate);
+      }
+
+      // Scan without identity (first tile).
+      // Without an identity, the first output item is undefined.
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t &tile_aggregate,
+                thrust::detail::false_type /* has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items, scan_items, scan_op, tile_aggregate);
+      }
+
+      // Scan with identity (subsequent tile)
+      //
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t & tile_aggregate,
+                TilePrefixCallback &prefix_op,
+                thrust::detail::true_type /*  has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items,
+                           scan_items,
+                           scan_op,
+                           prefix_op);
+        tile_aggregate = prefix_op.GetBlockAggregate();
+      }
+
+      // Scan without identity (subsequent tile).
+      // Without an identity, the first output item is undefined.
+      THRUST_DEVICE_FUNCTION void
+      scan_tile(size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+                size_value_pair_t & tile_aggregate,
+                TilePrefixCallback &prefix_op,
+                thrust::detail::false_type /* has_identity */)
+      {
+        BlockScan(storage.scan_storage.scan)
+            .ExclusiveScan(scan_items,
+                           scan_items,
+                           scan_op,
+                           prefix_op);
+        tile_aggregate = prefix_op.GetBlockAggregate();
+      }
+
+      //---------------------------------------------------------------------
+      // Zip utility methods
+      //---------------------------------------------------------------------
+
+
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      zip_values_and_flags(size_type num_remaining,
+                           value_type (&values)[ITEMS_PER_THREAD],
+                           size_type (&segment_flags)[ITEMS_PER_THREAD],
+                           size_value_pair_t (&scan_items)[ITEMS_PER_THREAD])
+      {
+        // Zip values and segment_flags
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set segment_flags for first out-of-bounds item, zero for others
+          if (IS_LAST_TILE &&
+              Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM == num_remaining)
+            segment_flags[ITEM] = 1;
+
+          scan_items[ITEM].value = values[ITEM];
+          scan_items[ITEM].key   = segment_flags[ITEM];
+        }
+      }
+
+      THRUST_DEVICE_FUNCTION void zip_keys_and_values(
+          key_type (&keys)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_value_pair_t (&scan_items)[ITEMS_PER_THREAD],
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD])
+      {
+        // Zip values and segment_flags
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          scatter_items[ITEM].key   = keys[ITEM];
+          scatter_items[ITEM].value = scan_items[ITEM].value;
+          segment_indices[ITEM]     = scan_items[ITEM].key;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Scatter utility methods
+      //---------------------------------------------------------------------
+
+      // Directly scatter flagged items to output offsets
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false)
+      THRUST_DEVICE_FUNCTION void scatter_direct(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD])
+      {
+        // Scatter flagged keys and values
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (segment_flags[ITEM])
+          {
+            keys_output_it[segment_indices[ITEM]] = scatter_items[ITEM].key;
+            values_output_it[segment_indices[ITEM]] = scatter_items[ITEM].value;
+          }
+        }
+      }
+
+      // 2-phase scatter flagged items to output offsets
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false
+      //
+      // The exclusive scan causes each head flag to be paired with
+      // the previous value aggregate:
+      //   * the scatter offsets must be decremented for value aggregates
+      //
+      THRUST_DEVICE_FUNCTION void scatter_two_phase(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_type num_tile_segments,
+          size_type num_tile_segments_prefix)
+      {
+        using core::sync_threadblock;
+
+        sync_threadblock();
+
+        // Compact and scatter keys
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (segment_flags[ITEM])
+          {
+            int idx = static_cast<int>(segment_indices[ITEM] -
+                                       num_tile_segments_prefix);
+            storage.raw_exchange[idx] = scatter_items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x; item < num_tile_segments; item += BLOCK_THREADS)
+        {
+          size_type        idx  = num_tile_segments_prefix + item;
+          key_value_pair_t pair = storage.raw_exchange[item];
+          keys_output_it[idx]   = pair.key;
+          values_output_it[idx] = pair.value;
+        }
+      }
+
+
+      // Scatter flagged items
+      //
+      THRUST_DEVICE_FUNCTION void scatter(
+          key_value_pair_t (&scatter_items)[ITEMS_PER_THREAD],
+          size_type (&segment_flags)[ITEMS_PER_THREAD],
+          size_type (&segment_indices)[ITEMS_PER_THREAD],
+          size_type num_tile_segments,
+          size_type num_tile_segments_prefix)
+      {
+        // Do a one-phase scatter if (a) two-phase is disabled or
+        // (b) the average number of selected items per thread is less than one
+        if (TWO_PHASE_SCATTER && (num_tile_segments > BLOCK_THREADS))
+        {
+          scatter_two_phase(scatter_items,
+                            segment_flags,
+                            segment_indices,
+                            num_tile_segments,
+                            num_tile_segments_prefix);
+        }
+        else
+        {
+          scatter_direct(scatter_items,
+                         segment_flags,
+                         segment_indices);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Finalization utility methods
+      //---------------------------------------------------------------------
+
+      // Finalize the carry-out from the last tile
+      // (specialized for IS_SEGMENTED_REDUCTION_FIXUP == false)
+      THRUST_DEVICE_FUNCTION void
+      finalize_last_tile(size_type num_segments,
+                         size_type num_remaining,
+                         key_type    last_key,
+                         value_type  last_value)
+      {
+        // Last thread will output final count and last item, if necessary
+        if (threadIdx.x == BLOCK_THREADS - 1)
+        {
+          // If the last tile is a whole tile, the inclusive prefix
+          // contains accumulated value reduction for the last segment
+          if (num_remaining == ITEMS_PER_TILE)
+          {
+            // Scatter key and value
+            keys_output_it[num_segments]   = last_key;
+            values_output_it[num_segments] = last_value;
+            num_segments++;
+          }
+
+          // Output the total number of items selected
+          *num_runs_output_it = num_segments;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Cooperatively scan a device-wide sequence of tiles with other CTAs
+      //---------------------------------------------------------------------
+
+      // Process first tile of input (dynamic chained scan).
+      // Returns the running  count of segments
+      // and aggregated values (including this tile)
+      //
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_first_tile(Size           num_remaining,
+                         Size           tile_offset,
+                         ScanTileState &tile_state)
+      {
+        using core::sync_threadblock;
+
+        key_type          keys[ITEMS_PER_THREAD];               // Tile keys
+        key_type          pred_keys[ITEMS_PER_THREAD];          // Tile keys shifted up (predecessor)
+        value_type        values[ITEMS_PER_THREAD];             // Tile values
+        size_type         segment_flags[ITEMS_PER_THREAD];      // Segment head flags
+        size_type         segment_indices[ITEMS_PER_THREAD];    // Segment indices
+        size_value_pair_t scan_items[ITEMS_PER_THREAD];         // Zipped values and segment flags|indices
+        key_value_pair_t  scatter_items[ITEMS_PER_THREAD];      // Zipped key value pairs for scattering
+
+        // Load keys (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset,
+                    keys,
+                    num_remaining,
+                    *(keys_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset, keys);
+        }
+
+        sync_threadblock();
+
+        // Load values (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset,
+                    values,
+                    num_remaining,
+                    *(values_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset, values);
+        }
+
+        sync_threadblock();
+
+        // Set head segment_flags.
+        // First tile sets the first flag for the first item
+        BlockDiscontinuityKeys(storage.scan_storage.discontinuity)
+            .FlagHeads(segment_flags, keys, pred_keys, inequality_op);
+
+        // Unset the flag for the first item in the first tile
+        // so we won't scatter it
+        //
+        if (threadIdx.x == 0)
+          segment_flags[0] = 0;
+
+        // Zip values and segment_flags
+        zip_values_and_flags<IS_LAST_TILE>(num_remaining,
+                                           values,
+                                           segment_flags,
+                                           scan_items);
+
+        // Exclusive scan of values and segment_flags
+        size_value_pair_t tile_aggregate;
+        scan_tile(scan_items, tile_aggregate, is_true<HAS_IDENTITY_ZERO>());
+
+        if (threadIdx.x == 0)
+        {
+          // Update tile status if this is not the last tile
+          if (!IS_LAST_TILE)
+            tile_state.SetInclusive(0, tile_aggregate);
+
+          // Initialize the segment index for the first scan item if necessary
+          // (the exclusive prefix for the first item is garbage)
+          if (!HAS_IDENTITY_ZERO)
+            scan_items[0].key = 0;
+        }
+
+        // Unzip values and segment indices
+        zip_keys_and_values(pred_keys,
+                            segment_indices,
+                            scan_items,
+                            scatter_items);
+
+        // Scatter flagged items
+        scatter(scatter_items,
+                segment_flags,
+                segment_indices,
+                tile_aggregate.key,
+                0);
+
+        if (IS_LAST_TILE)
+        {
+          // Finalize the carry-out from the last tile
+          finalize_last_tile(tile_aggregate.key,
+                             num_remaining,
+                             keys[ITEMS_PER_THREAD - 1],
+                             tile_aggregate.value);
+        }
+      }
+
+      // Process subsequent tile of input (dynamic chained scan).
+      // Returns the running count of segments
+      // and aggregated values (including this tile)
+
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_subsequent_tile(Size           num_remaining,
+                              int            tile_idx,
+                              Size           tile_offset,
+                              ScanTileState &tile_state)
+      {
+        using core::sync_threadblock;
+
+        key_type          keys[ITEMS_PER_THREAD];               // Tile keys
+        key_type          pred_keys[ITEMS_PER_THREAD];          // Tile keys shifted up (predecessor)
+        value_type        values[ITEMS_PER_THREAD];             // Tile values
+        size_type         segment_flags[ITEMS_PER_THREAD];      // Segment head flags
+        size_type         segment_indices[ITEMS_PER_THREAD];    // Segment indices
+        size_value_pair_t scan_items[ITEMS_PER_THREAD];         // Zipped values and segment flags|indices
+        key_value_pair_t  scatter_items[ITEMS_PER_THREAD];      // Zipped key value pairs for scattering
+
+        // Load keys (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset,
+                    keys,
+                    num_remaining,
+                    *(keys_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadKeys(storage.load_keys)
+              .Load(keys_load_it + tile_offset, keys);
+        }
+
+        key_type tile_pred_key = (threadIdx.x == 0)
+                                     ? keys_load_it[tile_offset - 1]
+                                     : key_type();
+
+        sync_threadblock();
+
+        // Load values (last tile repeats final element)
+        if (IS_LAST_TILE)
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset,
+                    values,
+                    num_remaining,
+                    *(values_load_it + tile_offset));
+        }
+        else
+        {
+          BlockLoadValues(storage.load_values)
+              .Load(values_load_it + tile_offset, values);
+        }
+
+        sync_threadblock();
+
+        // Set head segment_flags
+        BlockDiscontinuityKeys(storage.scan_storage.discontinuity)
+            .FlagHeads(segment_flags,
+                       keys,
+                       pred_keys,
+                       inequality_op,
+                       tile_pred_key);
+
+        // Zip values and segment_flags
+        zip_values_and_flags<IS_LAST_TILE>(num_remaining,
+                                           values,
+                                           segment_flags,
+                                           scan_items);
+
+        // Exclusive scan of values and segment_flags
+        size_value_pair_t  tile_aggregate;
+        TilePrefixCallback prefix_op(tile_state, storage.scan_storage.prefix, scan_op, tile_idx);
+        scan_tile(scan_items,
+                  tile_aggregate,
+                  prefix_op,
+                  is_true<HAS_IDENTITY_ZERO>());
+        size_value_pair_t tile_inclusive_prefix = prefix_op.GetInclusivePrefix();
+
+        // Unzip values and segment indices
+        zip_keys_and_values(pred_keys, segment_indices, scan_items, scatter_items);
+
+        // Scatter flagged items
+        scatter(scatter_items,
+                segment_flags,
+                segment_indices,
+                tile_aggregate.key,
+                prefix_op.GetExclusivePrefix().key);
+
+        if (IS_LAST_TILE)
+        {
+          // Finalize the carry-out from the last tile
+          finalize_last_tile(tile_inclusive_prefix.key,
+                             num_remaining,
+                             keys[ITEMS_PER_THREAD - 1],
+                             tile_inclusive_prefix.value);
+        }
+      }
+      template <bool IS_LAST_TILE>
+      THRUST_DEVICE_FUNCTION void
+      consume_tile(size_type      num_remaining,
+                   int            tile_idx,
+                   size_type      tile_offset,
+                   ScanTileState &tile_state)
+      {
+        if (tile_idx == 0)
+        {
+          consume_first_tile<IS_LAST_TILE>(num_remaining,
+                                           tile_offset,
+                                           tile_state);
+        }
+        else
+        {
+          consume_subsequent_tile<IS_LAST_TILE>(num_remaining,
+                                                tile_idx,
+                                                tile_offset,
+                                                tile_state);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor : consume_range
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION impl(TempStorage &   storage_,
+                                  KeysInputIt     keys_input_it_,
+                                  ValuesInputIt   values_input_it_,
+                                  KeysOutputIt    keys_output_it_,
+                                  ValuesOutputIt  values_output_it_,
+                                  NumRunsOutputIt num_runs_output_it_,
+                                  EqualityOp      equality_op_,
+                                  ReductionOp     reduction_op_,
+                                  Size            num_items,
+                                  int             /*num_tiles*/,
+                                  ScanTileState & tile_state)
+          : storage(storage_),
+            keys_load_it(core::make_load_iterator(ptx_plan(), keys_input_it_)),
+            values_load_it(core::make_load_iterator(ptx_plan(), values_input_it_)),
+            keys_output_it(keys_output_it_),
+            values_output_it(values_output_it_),
+            num_runs_output_it(num_runs_output_it_),
+            inequality_op(equality_op_),
+            scan_op(reduction_op_)
+      {
+        // Blocks are launched in increasing order,
+        // so just assign one tile per block
+        //
+        int  tile_idx          = blockIdx.x;
+        Size tile_offset       = static_cast<Size>(tile_idx) * ITEMS_PER_TILE;
+        Size num_remaining     = num_items - tile_offset;
+
+        if (num_remaining > ITEMS_PER_TILE)
+        {
+          // Not the last tile (full)
+          consume_tile<false>(num_remaining, tile_idx, tile_offset, tile_state);
+        }
+        else if (num_remaining > 0)
+        {
+          // The last tile (possibly partially-full)
+          consume_tile<true>(num_remaining, tile_idx, tile_offset, tile_state);
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysInputIt     keys_input_it,
+                       ValuesInputIt   values_input_it,
+                       KeysOutputIt    keys_output_it,
+                       ValuesOutputIt  values_output_it,
+                       NumRunsOutputIt num_runs_output_it,
+                       ScanTileState   tile_state,
+                       EqualityOp      equality_op,
+                       ReductionOp     reduction_op,
+                       Size            num_items,
+                       int             num_tiles,
+                       char *          shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage*>(shmem);
+
+      impl(storage,
+           keys_input_it,
+           values_input_it,
+           keys_output_it,
+           values_output_it,
+           num_runs_output_it,
+           equality_op,
+           reduction_op,
+           num_items,
+           num_tiles,
+           tile_state);
+    }
+
+  };    // struct ReduceByKeyAgent
+
+  template <class ScanTileState,
+            class Size,
+            class NumSelectedIt>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char *        /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+  }; // struct InitAgent
+
+  template <class KeysInputIt,
+            class ValuesInputIt,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class NumRunsOutputIt,
+            class EqualityOp,
+            class ReductionOp,
+            class Size>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *          d_temp_storage,
+            size_t &        temp_storage_bytes,
+            KeysInputIt     keys_input_it,
+            ValuesInputIt   values_input_it,
+            KeysOutputIt    keys_output_it,
+            ValuesOutputIt  values_output_it,
+            NumRunsOutputIt num_runs_output_it,
+            EqualityOp      equality_op,
+            ReductionOp     reduction_op,
+            Size            num_items,
+            cudaStream_t    stream)
+  {
+    using core::AgentPlan;
+    using core::AgentLauncher;
+
+    cudaError_t status = cudaSuccess;
+    if (num_items == 0)
+      return cudaErrorNotSupported;
+
+    typedef AgentLauncher<
+        ReduceByKeyAgent<KeysInputIt,
+                         ValuesInputIt,
+                         KeysOutputIt,
+                         ValuesOutputIt,
+                         EqualityOp,
+                         ReductionOp,
+                         NumRunsOutputIt,
+                         Size> >
+        reduce_by_key_agent;
+
+    typedef typename reduce_by_key_agent::ScanTileState ScanTileState;
+    typedef AgentLauncher<
+        InitAgent<ScanTileState,
+                  Size,
+                  NumRunsOutputIt> >
+        init_agent;
+
+    AgentPlan reduce_by_key_plan = reduce_by_key_agent::get_plan(stream);
+    AgentPlan init_plan          = init_agent::get_plan();
+
+    // Number of input tiles
+    int  tile_size = reduce_by_key_plan.items_per_tile;
+    Size num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(reduce_by_key_plan.shared_memory_size,
+                                           num_tiles);
+
+    size_t allocation_sizes[2] = {9, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_state;
+    status = tile_state.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    init_agent ia(init_plan, num_tiles, stream, "reduce_by_key::init_agent");
+    ia.launch(tile_state, num_tiles, num_runs_output_it);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    reduce_by_key_agent rbka(reduce_by_key_plan,
+                             num_items,
+                             stream,
+                             vshmem_ptr,
+                             "reduce_by_keys::reduce_by_key_agent");
+    rbka.launch(keys_input_it,
+                values_input_it,
+                keys_output_it,
+                values_output_it,
+                num_runs_output_it,
+                tile_state,
+                equality_op,
+                reduction_op,
+                num_items,
+                num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Size,
+            typename Derived,
+            typename KeysInputIt,
+            typename ValuesInputIt,
+            typename KeysOutputIt,
+            typename ValuesOutputIt,
+            typename EqualityOp,
+            typename ReductionOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  reduce_by_key_dispatch(execution_policy<Derived>& policy,
+                         KeysInputIt                keys_first,
+                         Size                       num_items,
+                         ValuesInputIt              values_first,
+                         KeysOutputIt               keys_output,
+                         ValuesOutputIt             values_output,
+                         EqualityOp                 equality_op,
+                         ReductionOp                reduction_op)
+  {
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    if (num_items == 0)
+    {
+      return thrust::make_pair(keys_output, values_output);
+    }
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       keys_first,
+                       values_first,
+                       keys_output,
+                       values_output,
+                       reinterpret_cast<Size*>(NULL),
+                       equality_op,
+                       reduction_op,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce_by_key failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(Size), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "reduce failed on 2nd alias_storage");
+
+    Size* d_num_runs_out
+      = thrust::detail::aligned_reinterpret_cast<Size*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       keys_first,
+                       values_first,
+                       keys_output,
+                       values_output,
+                       d_num_runs_out,
+                       equality_op,
+                       reduction_op,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "reduce_by_key failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "reduce_by_key: failed to synchronize");
+
+    int num_runs_out = cuda_cub::get_value(policy, d_num_runs_out);
+
+    return thrust::make_pair(
+      keys_output + num_runs_out,
+      values_output + num_runs_out
+    );
+  }
+
+  template <typename Derived,
+            typename KeysInputIt,
+            typename ValuesInputIt,
+            typename KeysOutputIt,
+            typename ValuesOutputIt,
+            typename EqualityOp,
+            typename ReductionOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  reduce_by_key(execution_policy<Derived>& policy,
+                KeysInputIt                keys_first,
+                KeysInputIt                keys_last,
+                ValuesInputIt              values_first,
+                KeysOutputIt               keys_output,
+                ValuesOutputIt             values_output,
+                EqualityOp                 equality_op,
+                ReductionOp                reduction_op)
+  {
+    using size_type = typename iterator_traits<KeysInputIt>::difference_type;
+
+    size_type num_items = thrust::distance(keys_first, keys_last);
+
+    pair<KeysOutputIt, ValuesOutputIt> result = thrust::make_pair(keys_output, values_output);
+
+    if (num_items == 0)
+    {
+      return result;
+    }
+
+    THRUST_INDEX_TYPE_DISPATCH(result,
+                               reduce_by_key_dispatch,
+                               num_items,
+                               (policy,
+                                keys_first,
+                                num_items_fixed,
+                                values_first,
+                                keys_output,
+                                values_output,
+                                equality_op,
+                                reduction_op));
+
+    return result;
+  }
+
+}    // namespace __reduce_by_key
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred,
+          class BinaryOp>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output,
+              BinaryPred                 binary_pred,
+              BinaryOp                   binary_op)
+{
+  auto ret = thrust::make_pair(keys_output, values_output);
+  THRUST_CDP_DISPATCH((ret = __reduce_by_key::reduce_by_key(policy,
+                                                            keys_first,
+                                                            keys_last,
+                                                            values_first,
+                                                            keys_output,
+                                                            values_output,
+                                                            binary_pred,
+                                                            binary_op);),
+                      (ret =
+                         thrust::reduce_by_key(cvt_to_seq(derived_cast(policy)),
+                                               keys_first,
+                                               keys_last,
+                                               values_first,
+                                               keys_output,
+                                               values_output,
+                                               binary_pred,
+                                               binary_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output,
+              BinaryPred                 binary_pred)
+{
+  typedef typename thrust::detail::eval_if<
+    thrust::detail::is_output_iterator<ValOutputIt>::value,
+    thrust::iterator_value<ValInputIt>,
+    thrust::iterator_value<ValOutputIt>
+  >::type value_type;
+  return cuda_cub::reduce_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              keys_output,
+                              values_output,
+                              binary_pred,
+                              plus<value_type>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+reduce_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              KeyOutputIt                keys_output,
+              ValOutputIt                values_output)
+{
+  typedef typename thrust::iterator_value<KeyInputIt>::type KeyT;
+  return cuda_cub::reduce_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              keys_output,
+                              values_output,
+                              equal_to<KeyT>());
+}
+
+} // namespace cuda_
+
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/reduce.h>
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/remove.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/remove.h
new file mode 100644
index 0000000000000000000000000000000000000000..836d8f5eab6f14a2ccc606bf426191210c8d7ccd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/remove.h
@@ -0,0 +1,134 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/copy_if.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+// in-place
+  
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class Predicate>
+InputIt __host__ __device__
+remove_if(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          StencilIt                  stencil,
+          Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, stencil, first,
+    thrust::detail::not1(predicate));
+}
+
+template <class Derived,
+          class InputIt,
+          class Predicate>
+InputIt __host__ __device__
+remove_if(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, first,
+    thrust::detail::not1(predicate));
+}
+
+
+template <class Derived,
+          class InputIt,
+          class T>
+InputIt __host__ __device__
+remove(execution_policy<Derived> &policy,
+       InputIt                    first,
+       InputIt                    last,
+       const T &                  value)
+{
+  using thrust::placeholders::_1;
+
+  return cuda_cub::remove_if(policy, first, last, _1 == value);
+}
+
+// copy
+
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class OutputIt,
+          class Predicate>
+OutputIt __host__ __device__
+remove_copy_if(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               StencilIt                  stencil,
+               OutputIt                   result,
+               Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, stencil, result,
+    thrust::detail::not1(predicate));
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class Predicate>
+OutputIt __host__ __device__
+remove_copy_if(execution_policy<Derived> &policy,
+               InputIt                    first,
+               InputIt                    last,
+               OutputIt                   result,
+               Predicate                  predicate)
+{
+  return cuda_cub::copy_if(policy, first, last, result,
+    thrust::detail::not1(predicate));
+}
+
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class T>
+OutputIt __host__ __device__
+remove_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result,
+            const T &                  value)
+{
+  thrust::detail::equal_to_value<T> pred(value);
+  return cuda_cub::remove_copy_if(policy, first, last, result, pred);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/replace.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/replace.h
new file mode 100644
index 0000000000000000000000000000000000000000..af8b8fa95633c40a3e174fa5003cb48b7db9fddf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/replace.h
@@ -0,0 +1,213 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/detail/internal_functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+  namespace __replace
+  {
+    template<class T>
+    struct constant_f
+    {
+      T value;
+
+      THRUST_FUNCTION
+      constant_f(T const &x) : value(x) {}
+
+      template<class U>
+      THRUST_DEVICE_FUNCTION
+      T operator()(U const &)  const
+      {
+        return value;
+      }
+    }; // struct constant_f
+
+    template<class Predicate, class NewType, class OutputType>
+    struct new_value_if_f
+    {
+      Predicate pred;
+      NewType new_value;
+
+      THRUST_FUNCTION
+      new_value_if_f(Predicate pred_, NewType new_value_)
+          : pred(pred_), new_value(new_value_) {}
+
+      template<class T>
+      OutputType THRUST_DEVICE_FUNCTION
+      operator()(T const &x)
+      {
+        return pred(x) ? new_value : x;
+      }
+
+      template<class T, class P>
+      OutputType THRUST_DEVICE_FUNCTION
+      operator()(T const &x, P const& y)
+      {
+        return pred(y) ? new_value : x;
+      }
+    }; // struct new_value_if_f
+
+  } // namespace __replace
+
+template <class Derived,
+          class Iterator,
+          class T>
+void __host__ __device__
+replace(execution_policy<Derived> &policy,
+        Iterator                   first,
+        Iterator                   last,
+        T const &                  old_value,
+        T const &                  new_value)
+{
+  using thrust::placeholders::_1;
+
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      _1 == old_value);
+}
+
+template <class Derived,
+          class Iterator,
+          class Predicate,
+          class T>
+void __host__ __device__
+replace_if(execution_policy<Derived> &policy,
+           Iterator                   first,
+           Iterator                   last,
+           Predicate                  pred,
+           T const &                  new_value)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      pred);
+}
+
+template <class Derived,
+          class Iterator,
+          class StencilIt,
+          class Predicate,
+          class T>
+void __host__ __device__
+replace_if(execution_policy<Derived> &policy,
+           Iterator                   first,
+           Iterator                   last,
+           StencilIt                  stencil,
+           Predicate                  pred,
+           T const &                  new_value)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      stencil,
+                      first,
+                      __replace::constant_f<T>(new_value),
+                      pred);
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class Predicate,
+          class T>
+OutputIt __host__ __device__
+replace_copy_if(execution_policy<Derived> &policy,
+                InputIt                    first,
+                InputIt                    last,
+                OutputIt                   result,
+                Predicate                  predicate,
+                T const &                  new_value)
+{
+  typedef typename iterator_traits<OutputIt>::value_type output_type;
+  typedef __replace::new_value_if_f<Predicate, T, output_type> new_value_if_t;
+  return cuda_cub::transform(policy,
+                             first,
+                             last,
+                             result,
+                             new_value_if_t(predicate, new_value));
+}
+
+template <class Derived,
+          class InputIt,
+          class StencilIt,
+          class OutputIt,
+          class Predicate,
+          class T>
+OutputIt __host__ __device__
+replace_copy_if(execution_policy<Derived> &policy,
+                InputIt                    first,
+                InputIt                    last,
+                StencilIt                  stencil,
+                OutputIt                   result,
+                Predicate                  predicate,
+                T const &                  new_value)
+{
+  typedef typename iterator_traits<OutputIt>::value_type output_type;
+  typedef __replace::new_value_if_f<Predicate, T, output_type> new_value_if_t;
+  return cuda_cub::transform(policy,
+                           first,
+                           last,
+                           stencil,
+                           result,
+                           new_value_if_t(predicate, new_value));
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class T>
+OutputIt __host__ __device__
+replace_copy(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             OutputIt                   result,
+             T const &                  old_value,
+             T const &                  new_value)
+{
+  return cuda_cub::replace_copy_if(policy,
+                                   first,
+                                   last,
+                                   result,
+                                   thrust::detail::equal_to_value<T>(old_value),
+                                   new_value);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reverse.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reverse.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c4cb867e3265d05c8cb72c9ce0c3e38f530ff5b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/reverse.h
@@ -0,0 +1,97 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived, class ItemsIt, class ResultIt>
+ResultIt __host__ __device__
+reverse_copy(execution_policy<Derived> &policy,
+             ItemsIt                    first,
+             ItemsIt                    last,
+             ResultIt                   result);
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+reverse(execution_policy<Derived> &policy,
+        ItemsIt                    first,
+        ItemsIt                    last);
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/swap_ranges.h>
+#include <thrust/system/cuda/detail/copy.h>
+#include <thrust/iterator/reverse_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class ItemsIt,
+          class ResultIt>
+ResultIt __host__ __device__
+reverse_copy(execution_policy<Derived> &policy,
+             ItemsIt                    first,
+             ItemsIt                    last,
+             ResultIt                   result)
+{
+  return cuda_cub::copy(policy,
+                        thrust::make_reverse_iterator(last),
+                        thrust::make_reverse_iterator(first),
+                        result);
+}
+
+template <class Derived,
+          class ItemsIt>
+void __host__ __device__
+reverse(execution_policy<Derived> &policy,
+        ItemsIt                    first,
+        ItemsIt                    last)
+{
+  typedef typename thrust::iterator_difference<ItemsIt>::type difference_type;
+
+  // find the midpoint of [first,last)
+  difference_type N = thrust::distance(first, last);
+  ItemsIt mid(first);
+  thrust::advance(mid, N / 2);
+
+  cuda_cub::swap_ranges(policy, first, mid, thrust::make_reverse_iterator(last));
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdab8df8447dfba71521d7de3a2eb9ec28817586
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan.h
@@ -0,0 +1,356 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/config/exec_check_disable.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+
+#include <cub/device/device_scan.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan_n_impl(thrust::cuda_cub::execution_policy<Derived> &policy,
+                               InputIt first,
+                               Size num_items,
+                               OutputIt result,
+                               ScanOp scan_op)
+{
+  using AccumT = typename thrust::iterator_traits<InputIt>::value_type;
+  using Dispatch32 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       cub::NullType,
+                                       thrust::detail::int32_t,
+                                       AccumT>;
+  using Dispatch64 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       cub::NullType,
+                                       thrust::detail::int64_t,
+                                       AccumT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status;
+
+  // Determine temporary storage requirements:
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching inclusive_scan kernel");
+    thrust::cuda_cub::throw_on_error(thrust::cuda_cub::synchronize_optional(policy),
+                                     "inclusive_scan failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename InitValueT,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan_n_impl(thrust::cuda_cub::execution_policy<Derived> &policy,
+                               InputIt first,
+                               Size num_items,
+                               OutputIt result,
+                               InitValueT init,
+                               ScanOp scan_op)
+{
+  using InputValueT = cub::detail::InputValue<InitValueT>;
+  using Dispatch32 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       InputValueT,
+                                       thrust::detail::int32_t,
+                                       InitValueT>;
+  using Dispatch64 = cub::DispatchScan<InputIt,
+                                       OutputIt,
+                                       ScanOp,
+                                       InputValueT,
+                                       thrust::detail::int64_t,
+                                       InitValueT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status;
+
+  // Determine temporary storage requirements:
+  size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 InputValueT(init),
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 first,
+                                 result,
+                                 scan_op,
+                                 InputValueT(init),
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after dispatching exclusive_scan kernel");
+    thrust::cuda_cub::throw_on_error(thrust::cuda_cub::synchronize_optional(policy),
+                                     "exclusive_scan failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+} // namespace detail
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan_n(thrust::cuda_cub::execution_policy<Derived> &policy,
+                          InputIt first,
+                          Size num_items,
+                          OutputIt result,
+                          ScanOp scan_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = thrust::cuda_cub::detail::inclusive_scan_n_impl(policy,
+                                                              first,
+                                                              num_items,
+                                                              result,
+                                                              scan_op);),
+    (result = thrust::inclusive_scan(cvt_to_seq(derived_cast(policy)),
+                                     first,
+                                     first + num_items,
+                                     result,
+                                     scan_op);));
+  return result;
+}
+
+template <typename Derived, typename InputIt, typename OutputIt, typename ScanOp>
+__host__ __device__
+OutputIt inclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        ScanOp scan_op)
+{
+  using diff_t = typename thrust::iterator_traits<InputIt>::difference_type;
+  diff_t const num_items = thrust::distance(first, last);
+  return thrust::cuda_cub::inclusive_scan_n(policy,
+                                            first,
+                                            num_items,
+                                            result,
+                                            scan_op);
+}
+
+template <typename Derived, typename InputIt, typename OutputIt>
+__host__ __device__
+OutputIt inclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result)
+{
+  return thrust::cuda_cub::inclusive_scan(policy,
+                                          first,
+                                          last,
+                                          result,
+                                          thrust::plus<>{});
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          typename T,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan_n(thrust::cuda_cub::execution_policy<Derived> &policy,
+                          InputIt first,
+                          Size num_items,
+                          OutputIt result,
+                          T init,
+                          ScanOp scan_op)
+{
+  THRUST_CDP_DISPATCH(
+    (result = thrust::cuda_cub::detail::exclusive_scan_n_impl(policy,
+                                                              first,
+                                                              num_items,
+                                                              result,
+                                                              init,
+                                                              scan_op);),
+    (result = thrust::exclusive_scan(cvt_to_seq(derived_cast(policy)),
+                                     first,
+                                     first + num_items,
+                                     result,
+                                     init,
+                                     scan_op);));
+  return result;
+}
+
+template <typename Derived,
+          typename InputIt,
+          typename OutputIt,
+          typename T,
+          typename ScanOp>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        T init,
+                        ScanOp scan_op)
+{
+  using diff_t = typename thrust::iterator_traits<InputIt>::difference_type;
+  diff_t const num_items = thrust::distance(first, last);
+  return thrust::cuda_cub::exclusive_scan_n(policy,
+                                            first,
+                                            num_items,
+                                            result,
+                                            init,
+                                            scan_op);
+}
+
+template <typename Derived, typename InputIt, typename OutputIt, typename T>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result,
+                        T init)
+{
+  return thrust::cuda_cub::exclusive_scan(policy,
+                                          first,
+                                          last,
+                                          result,
+                                          init,
+                                          thrust::plus<>{});
+}
+
+template <typename Derived, typename InputIt, typename OutputIt>
+__host__ __device__
+OutputIt exclusive_scan(thrust::cuda_cub::execution_policy<Derived> &policy,
+                        InputIt first,
+                        InputIt last,
+                        OutputIt result)
+{
+  using init_type = typename thrust::iterator_traits<InputIt>::value_type;
+  return cuda_cub::exclusive_scan(policy, first, last, result, init_type{});
+};
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/scan.h>
+
+#endif // NVCC
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..0407779c6e095c11ec624102be09361516e1d8ad
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scan_by_key.h
@@ -0,0 +1,492 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <thrust/iterator/iterator_traits.h>
+
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/temporary_array.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/dispatch.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/dispatch/dispatch_scan_by_key.cuh>
+#include <cub/util_type.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename KeysInIt,
+          typename ValuesInIt,
+          typename ValuesOutIt,
+          typename EqualityOpT,
+          typename ScanOpT,
+          typename SizeT>
+__host__ __device__
+ValuesOutIt inclusive_scan_by_key_n(
+  thrust::cuda_cub::execution_policy<Derived>& policy,
+  KeysInIt keys,
+  ValuesInIt values,
+  ValuesOutIt result,
+  SizeT num_items,
+  EqualityOpT equality_op,
+  ScanOpT scan_op)
+{
+  if (num_items == 0)
+  {
+    return result;
+  }
+
+  // Convert to raw pointers if possible:
+  using KeysInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<KeysInIt>;
+  using ValuesInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesInIt>;
+  using ValuesOutUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesOutIt>;
+  using AccumT = typename thrust::iterator_traits<ValuesInUnwrapIt>::value_type;
+
+  auto keys_unwrap = thrust::detail::try_unwrap_contiguous_iterator(keys);
+  auto values_unwrap = thrust::detail::try_unwrap_contiguous_iterator(values);
+  auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+  using Dispatch32 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            cub::NullType,
+                                            thrust::detail::int32_t,
+                                            AccumT>;
+  using Dispatch64 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            cub::NullType,
+                                            thrust::detail::int64_t,
+                                            AccumT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status{};
+
+  // Determine temporary storage requirements:
+  std::size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for inclusive_scan_by_key");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 cub::NullType{},
+                                 num_items_fixed,
+                                 stream));
+
+    thrust::cuda_cub::throw_on_error(
+      status, "after dispatching inclusive_scan_by_key kernel");
+
+    thrust::cuda_cub::throw_on_error(
+      thrust::cuda_cub::synchronize_optional(policy),
+      "inclusive_scan_by_key failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+__thrust_exec_check_disable__
+template <typename Derived,
+          typename KeysInIt,
+          typename ValuesInIt,
+          typename ValuesOutIt,
+          typename InitValueT,
+          typename EqualityOpT,
+          typename ScanOpT,
+          typename SizeT>
+__host__ __device__
+ValuesOutIt exclusive_scan_by_key_n(
+  thrust::cuda_cub::execution_policy<Derived>& policy,
+  KeysInIt keys,
+  ValuesInIt values,
+  ValuesOutIt result,
+  SizeT num_items,
+  InitValueT init_value,
+  EqualityOpT equality_op,
+  ScanOpT scan_op)
+{
+
+  if (num_items == 0)
+  {
+    return result;
+  }
+
+  // Convert to raw pointers if possible:
+  using KeysInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<KeysInIt>;
+  using ValuesInUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesInIt>;
+  using ValuesOutUnwrapIt =
+    thrust::detail::try_unwrap_contiguous_iterator_return_t<ValuesOutIt>;
+
+  auto keys_unwrap = thrust::detail::try_unwrap_contiguous_iterator(keys);
+  auto values_unwrap = thrust::detail::try_unwrap_contiguous_iterator(values);
+  auto result_unwrap = thrust::detail::try_unwrap_contiguous_iterator(result);
+
+  using Dispatch32 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            InitValueT,
+                                            thrust::detail::int32_t,
+                                            InitValueT>;
+  using Dispatch64 = cub::DispatchScanByKey<KeysInUnwrapIt,
+                                            ValuesInUnwrapIt,
+                                            ValuesOutUnwrapIt,
+                                            EqualityOpT,
+                                            ScanOpT,
+                                            InitValueT,
+                                            thrust::detail::int64_t,
+                                            InitValueT>;
+
+  cudaStream_t stream = thrust::cuda_cub::stream(policy);
+  cudaError_t status{};
+
+  // Determine temporary storage requirements:
+  std::size_t tmp_size = 0;
+  {
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (nullptr,
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 init_value,
+                                 num_items_fixed,
+                                 stream));
+    thrust::cuda_cub::throw_on_error(status,
+                                     "after determining tmp storage "
+                                     "requirements for exclusive_scan_by_key");
+  }
+
+  // Run scan:
+  {
+    // Allocate temporary storage:
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived> tmp{
+      policy,
+      tmp_size};
+
+    THRUST_INDEX_TYPE_DISPATCH2(status,
+                                Dispatch32::Dispatch,
+                                Dispatch64::Dispatch,
+                                num_items,
+                                (tmp.data().get(),
+                                 tmp_size,
+                                 keys_unwrap,
+                                 values_unwrap,
+                                 result_unwrap,
+                                 equality_op,
+                                 scan_op,
+                                 init_value,
+                                 num_items_fixed,
+                                 stream));
+
+    thrust::cuda_cub::throw_on_error(
+      status, "after dispatching exclusive_scan_by_key kernel");
+
+    thrust::cuda_cub::throw_on_error(
+      thrust::cuda_cub::synchronize_optional(policy),
+      "exclusive_scan_by_key failed to synchronize");
+  }
+
+  return result + num_items;
+}
+
+
+} // namespace detail
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+//---------------------------
+//   Inclusive scan
+//---------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class BinaryPred,
+          class ScanOp>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      BinaryPred                 binary_pred,
+                      ScanOp                     scan_op)
+{
+  ValOutputIt ret = value_result;
+  THRUST_CDP_DISPATCH(
+    (ret = thrust::cuda_cub::detail::inclusive_scan_by_key_n(
+       policy,
+       key_first,
+       value_first,
+       value_result,
+       thrust::distance(key_first, key_last),
+       binary_pred,
+       scan_op);),
+    (ret = thrust::inclusive_scan_by_key(cvt_to_seq(derived_cast(policy)),
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         binary_pred,
+                                         scan_op);));
+
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class BinaryPred>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      BinaryPred                 binary_pred)
+{
+  return cuda_cub::inclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         binary_pred,
+                                         thrust::plus<>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt>
+ValOutputIt __host__ __device__
+inclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result)
+{
+  return cuda_cub::inclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         thrust::equal_to<>());
+}
+
+
+//---------------------------
+//   Exclusive scan
+//---------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init,
+          class BinaryPred,
+          class ScanOp>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init,
+                      BinaryPred                 binary_pred,
+                      ScanOp                     scan_op)
+{
+  ValOutputIt ret = value_result;
+  THRUST_CDP_DISPATCH(
+    (ret = thrust::cuda_cub::detail::exclusive_scan_by_key_n(
+       policy,
+       key_first,
+       value_first,
+       value_result,
+       thrust::distance(key_first, key_last),
+       init,
+       binary_pred,
+       scan_op);),
+    (ret = thrust::exclusive_scan_by_key(cvt_to_seq(derived_cast(policy)),
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         binary_pred,
+                                         scan_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init,
+          class BinaryPred>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init,
+                      BinaryPred                 binary_pred)
+{
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         binary_pred,
+                                         thrust::plus<>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt,
+          class Init>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result,
+                      Init                       init)
+{
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         init,
+                                         thrust::equal_to<>());
+}
+
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class ValOutputIt>
+ValOutputIt __host__ __device__
+exclusive_scan_by_key(execution_policy<Derived> &policy,
+                      KeyInputIt                 key_first,
+                      KeyInputIt                 key_last,
+                      ValInputIt                 value_first,
+                      ValOutputIt                value_result)
+{
+  using value_type = typename thrust::iterator_traits<ValInputIt>::value_type;
+  return cuda_cub::exclusive_scan_by_key(policy,
+                                         key_first,
+                                         key_last,
+                                         value_first,
+                                         value_result,
+                                         value_type{});
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/scan.h>
+
+#endif // NVCC
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scatter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e297d782d71f0586bd43bb51740f5e3d4eebeeb5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/scatter.h
@@ -0,0 +1,106 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/iterator/permutation_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class ResultIt>
+void __host__ __device__
+scatter(execution_policy<Derived>& policy,
+        ItemsIt                    first,
+        ItemsIt                    last,
+        MapIt                      map,
+        ResultIt                   result)
+{
+  cuda_cub::transform(policy,
+                   first,
+                   last,
+                   thrust::make_permutation_iterator(result, map),
+                   identity());
+}
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class StencilIt,
+          class ResultIt,
+          class Predicate>
+void __host__ __device__
+scatter_if(execution_policy<Derived>& policy,
+           ItemsIt                    first,
+           ItemsIt                    last,
+           MapIt                      map,
+           StencilIt                  stencil,
+           ResultIt                   result,
+           Predicate                  predicate)
+{
+  cuda_cub::transform_if(policy,
+                      first,
+                      last,
+                      stencil,
+                      thrust::make_permutation_iterator(result, map),
+                      identity(),
+                      predicate);
+}
+
+template <class Derived,
+          class ItemsIt,
+          class MapIt,
+          class StencilIt,
+          class ResultIt,
+          class Predicate>
+void __host__ __device__
+scatter_if(execution_policy<Derived>& policy,
+           ItemsIt                    first,
+           ItemsIt                    last,
+           MapIt                      map,
+           StencilIt                  stencil,
+           ResultIt                   result)
+{
+  cuda_cub::scatter_if(policy,
+                    first,
+                    last,
+                    map,
+                    stencil,
+                    result,
+                    identity());
+}
+
+
+} // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sequence.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sequence.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6ae90664ad9538e73febfde86c334011de417c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sequence.h
@@ -0,0 +1,22 @@
+/*
+ *  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>
+
+// this system has no special version of this algorithm 
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/set_operations.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/set_operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..98bb4bb5d6903800c3d23ed45b99f550e8e210ca
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/set_operations.h
@@ -0,0 +1,1939 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/pair.h>
+#include <thrust/set_operations.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __set_operations {
+
+  template <bool UpperBound,
+            class IntT,
+            class Size,
+            class It,
+            class T,
+            class Comp>
+  THRUST_DEVICE_FUNCTION void
+  binary_search_iteration(It   data,
+                          Size &begin,
+                          Size &end,
+                          T    key,
+                          int  shift,
+                          Comp comp)
+  {
+
+    IntT scale = (1 << shift) - 1;
+    Size mid   = (begin + scale * end) >> shift;
+
+    T    key2 = data[mid];
+    bool pred = UpperBound ? !comp(key, key2) : comp(key2, key);
+    if (pred)
+      begin = mid + 1;
+    else
+      end = mid;
+  }
+
+  template <bool UpperBound, class Size, class T, class It, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  binary_search(It data, Size count, T key, Comp comp)
+  {
+    Size begin = 0;
+    Size end   = count;
+    while (begin < end)
+      binary_search_iteration<UpperBound, int>(data,
+                                               begin,
+                                               end,
+                                               key,
+                                               1,
+                                               comp);
+    return begin;
+  }
+
+  template <bool UpperBound, class IntT, class Size, class T, class It, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  biased_binary_search(It data, Size count, T key, IntT levels, Comp comp)
+  {
+    Size begin = 0;
+    Size end   = count;
+
+    if (levels >= 4 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 9, comp);
+    if (levels >= 3 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 7, comp);
+    if (levels >= 2 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 5, comp);
+    if (levels >= 1 && begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 4, comp);
+
+    while (begin < end)
+      binary_search_iteration<UpperBound, IntT>(data, begin, end, key, 1, comp);
+    return begin;
+  }
+
+  template <bool UpperBound, class Size, class It1, class It2, class Comp>
+  THRUST_DEVICE_FUNCTION Size
+  merge_path(It1 a, Size aCount, It2 b, Size bCount, Size diag, Comp comp)
+  {
+    typedef typename thrust::iterator_traits<It1>::value_type T;
+
+    Size begin = thrust::max<Size>(0, diag - bCount);
+    Size end   = thrust::min<Size>(diag, aCount);
+
+    while (begin < end)
+    {
+      Size  mid  = (begin + end) >> 1;
+      T    aKey = a[mid];
+      T    bKey = b[diag - 1 - mid];
+      bool pred = UpperBound ? comp(aKey, bKey) : !comp(bKey, aKey);
+      if (pred)
+        begin = mid + 1;
+      else
+        end = mid;
+    }
+    return begin;
+  }
+
+  template <class It1, class It2, class Size, class Size2, class CompareOp>
+  THRUST_DEVICE_FUNCTION pair<Size, Size>
+  balanced_path(It1       keys1,
+                It2       keys2,
+                Size      num_keys1,
+                Size      num_keys2,
+                Size      diag,
+                Size2     levels,
+                CompareOp compare_op)
+  {
+    typedef typename iterator_traits<It1>::value_type T;
+
+    Size index1 = merge_path<false>(keys1,
+                                    num_keys1,
+                                    keys2,
+                                    num_keys2,
+                                    diag,
+                                    compare_op);
+    Size index2 = diag - index1;
+
+    bool star = false;
+    if (index2 < num_keys2)
+    {
+      T x = keys2[index2];
+
+      // Search for the beginning of the duplicate run in both A and B.
+      Size start1 = biased_binary_search<false>(keys1,
+                                                index1,
+                                                x,
+                                                levels,
+                                                compare_op);
+      Size start2 = biased_binary_search<false>(keys2,
+                                                index2,
+                                                x,
+                                                levels,
+                                                compare_op);
+
+      // The distance between x's merge path and its lower_bound is its rank.
+      // We add up the a and b ranks and evenly distribute them to
+      // get a stairstep path.
+      Size run1      = index1 - start1;
+      Size run2      = index2 - start2;
+      Size total_run = run1 + run2;
+
+      // Attempt to advance b and regress a.
+      Size advance2 = max<Size>(total_run >> 1, total_run - run1);
+      Size end2     = min<Size>(num_keys2, start2 + advance2 + 1);
+
+      Size run_end2 = index2 + binary_search<true>(keys2 + index2,
+                                                   end2 - index2,
+                                                   x,
+                                                   compare_op);
+      run2 = run_end2 - start2;
+
+      advance2      = min<Size>(advance2, run2);
+      Size advance1 = total_run - advance2;
+
+      bool round_up      = (advance1 == advance2 + 1) && (advance2 < run2);
+      if (round_up) star = true;
+
+      index1 = start1 + advance1;
+    }
+    return thrust::make_pair(index1, (diag - index1) + star);
+  }    // func balanced_path
+
+  template <int                      _BLOCK_THREADS,
+            int                      _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm  _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier   _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm  _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD - 1
+    };
+
+    static const cub::BlockLoadAlgorithm  LOAD_ALGORITHM  = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier   LOAD_MODIFIER   = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm  SCAN_ALGORITHM  = _SCAN_ALGORITHM;
+  };    // PtxPolicy
+
+  template<class Arch, class T, class U>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, class U>
+  struct Tuning<sm30,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T),    // + sizeof(Value),
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm30
+
+  template<class T, class U>
+  struct Tuning<sm52,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T), // + sizeof(U),
+      NOMINAL_4B_ITEMS_PER_THREAD = 15,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<256,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm52
+
+  template<class T, class U>
+  struct Tuning<sm60,T,U>
+  {
+    enum
+    {
+      MAX_INPUT_BYTES             = mpl::max<size_t, sizeof(T), sizeof(U)>::value,
+      COMBINED_INPUT_BYTES        = sizeof(T), // + sizeof(U),
+      NOMINAL_4B_ITEMS_PER_THREAD = 19,
+      ITEMS_PER_THREAD            = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<
+              int,
+              1,
+              static_cast<int>(((NOMINAL_4B_ITEMS_PER_THREAD * 4) +
+               COMBINED_INPUT_BYTES - 1) /
+                  COMBINED_INPUT_BYTES)>::value>::value,
+    };
+
+    typedef PtxPolicy<512,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  }; // tuning sm60
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class ValuesIt1,
+            class ValuesIt2,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class Size,
+            class CompareOp,
+            class SetOp,
+            class HAS_VALUES>
+  struct SetOpAgent
+  {
+    typedef typename iterator_traits<KeysIt1>::value_type  key1_type;
+    typedef typename iterator_traits<KeysIt2>::value_type  key2_type;
+    typedef typename iterator_traits<ValuesIt1>::value_type value1_type;
+    typedef typename iterator_traits<ValuesIt2>::value_type value2_type;
+
+    typedef key1_type  key_type;
+    typedef value1_type value_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, key_type, value_type>::type
+    {
+      typedef Tuning<Arch, key_type, value_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeysIt1>::type   KeysLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, KeysIt2>::type   KeysLoadIt2;
+      typedef typename core::LoadIterator<PtxPlan, ValuesIt1>::type ValuesLoadIt1;
+      typedef typename core::LoadIterator<PtxPlan, ValuesIt2>::type ValuesLoadIt2;
+
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt1>::type   BlockLoadKeys1;
+      typedef typename core::BlockLoad<PtxPlan, KeysLoadIt2>::type   BlockLoadKeys2;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt1>::type BlockLoadValues1;
+      typedef typename core::BlockLoad<PtxPlan, ValuesLoadIt2>::type BlockLoadValues2;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      // gather required temporary storage in a union
+      //
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage          scan;
+          typename TilePrefixCallback::TempStorage prefix;
+        } scan_storage;
+
+        struct LoadStorage
+        {
+          core::uninitialized_array<int, PtxPlan::BLOCK_THREADS> offset;
+          union
+          {
+            // FIXME These don't appear to be used anywhere?
+            typename BlockLoadKeys1::TempStorage   load_keys1;
+            typename BlockLoadKeys2::TempStorage   load_keys2;
+            typename BlockLoadValues1::TempStorage load_values1;
+            typename BlockLoadValues2::TempStorage load_values2;
+
+            // Allocate extra shmem than truely neccessary
+            // This will permit to avoid range checks in
+            // serial set operations, e.g. serial_set_difference
+            core::uninitialized_array<
+                key_type,
+                PtxPlan::ITEMS_PER_TILE + PtxPlan::BLOCK_THREADS>
+                keys_shared;
+
+            core::uninitialized_array<
+                value_type,
+                PtxPlan::ITEMS_PER_TILE + PtxPlan::BLOCK_THREADS>
+                values_shared;
+          }; // anon union
+        } load_storage; // struct LoadStorage
+      };    // union TempStorage
+    };      // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeysLoadIt1   KeysLoadIt1;
+    typedef typename ptx_plan::KeysLoadIt2   KeysLoadIt2;
+    typedef typename ptx_plan::ValuesLoadIt1 ValuesLoadIt1;
+    typedef typename ptx_plan::ValuesLoadIt2 ValuesLoadIt2;
+
+    typedef typename ptx_plan::BlockLoadKeys1   BlockLoadKeys1;
+    typedef typename ptx_plan::BlockLoadKeys2   BlockLoadKeys2;
+    typedef typename ptx_plan::BlockLoadValues1 BlockLoadValues1;
+    typedef typename ptx_plan::BlockLoadValues2 BlockLoadValues2;
+
+    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan BlockScan;
+
+    typedef typename ptx_plan::TempStorage TempStorage;
+
+    enum
+    {
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &  storage;
+      ScanTileState &tile_state;
+      KeysLoadIt1    keys1_in;
+      KeysLoadIt2    keys2_in;
+      ValuesLoadIt1  values1_in;
+      ValuesLoadIt2  values2_in;
+      Size           keys1_count;
+      Size           keys2_count;
+      KeysOutputIt   keys_out;
+      ValuesOutputIt values_out;
+      CompareOp      compare_op;
+      SetOp          set_op;
+      pair<Size, Size> *partitions;
+      std::size_t *output_count;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      template <bool IS_FULL_TILE, class T, class It1, class It2>
+      THRUST_DEVICE_FUNCTION void
+      gmem_to_reg(T (&output)[ITEMS_PER_THREAD],
+                  It1 input1,
+                  It2 input2,
+                  int count1,
+                  int count2)
+      {
+        if (IS_FULL_TILE)
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD - 1; ++ITEM)
+          {
+            int idx      = BLOCK_THREADS * ITEM + threadIdx.x;
+            output[ITEM] = (idx < count1)
+                               ? static_cast<T>(input1[idx])
+                               : static_cast<T>(input2[idx - count1]);
+          }
+
+          // last ITEM might be a conditional load even for full tiles
+          // please check first before attempting to load.
+          int ITEM = ITEMS_PER_THREAD - 1;
+          int idx  = BLOCK_THREADS * ITEM + threadIdx.x;
+          if (idx < count1 + count2)
+            output[ITEM] = (idx < count1)
+                               ? static_cast<T>(input1[idx])
+                               : static_cast<T>(input2[idx - count1]);
+        }
+        else
+        {
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+            if (idx < count1 + count2)
+            {
+              output[ITEM] = (idx < count1)
+                                 ? static_cast<T>(input1[idx])
+                                 : static_cast<T>(input2[idx - count1]);
+            }
+          }
+        }
+      }
+
+      template <class T, class It>
+      THRUST_DEVICE_FUNCTION void
+      reg_to_shared(It output,
+                    T (&input)[ITEMS_PER_THREAD])
+      {
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int idx = BLOCK_THREADS * ITEM + threadIdx.x;
+          output[idx] = input[ITEM];
+        }
+      }
+
+      template <class OutputIt, class T, class SharedIt>
+      void THRUST_DEVICE_FUNCTION
+      scatter(OutputIt output,
+              T (&input)[ITEMS_PER_THREAD],
+              SharedIt shared,
+              int      active_mask,
+              Size     thread_output_prefix,
+              Size     tile_output_prefix,
+              int      tile_output_count)
+      {
+        using core::sync_threadblock;
+
+
+
+        int local_scatter_idx = thread_output_prefix - tile_output_prefix;
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          if (active_mask & (1 << ITEM))
+          {
+            shared[local_scatter_idx++] = input[ITEM];
+          }
+        }
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < tile_output_count;
+             item += BLOCK_THREADS)
+        {
+          output[tile_output_prefix + item] = shared[item];
+        }
+      }
+
+      int THRUST_DEVICE_FUNCTION
+      serial_set_op(key_type *keys,
+                    int       keys1_beg,
+                    int       keys2_beg,
+                    int       keys1_count,
+                    int       keys2_count,
+                    key_type (&output)[ITEMS_PER_THREAD],
+                    int (&indices)[ITEMS_PER_THREAD],
+                    CompareOp compare_op,
+                    SetOp     set_op)
+      {
+        int active_mask = set_op(keys,
+                                 keys1_beg,
+                                 keys2_beg,
+                                 keys1_count,
+                                 keys2_count,
+                                 output,
+                                 indices,
+                                 compare_op);
+
+        return active_mask;
+      }
+
+      //---------------------------------------------------------------------
+      // Tile operations
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE>
+      void THRUST_DEVICE_FUNCTION
+      consume_tile(Size tile_idx)
+      {
+        using core::sync_threadblock;
+        using core::uninitialized_array;
+
+        pair<Size, Size> partition_beg = partitions[tile_idx + 0];
+        pair<Size, Size> partition_end = partitions[tile_idx + 1];
+
+        Size keys1_beg = partition_beg.first;
+        Size keys1_end = partition_end.first;
+        Size keys2_beg = partition_beg.second;
+        Size keys2_end = partition_end.second;
+
+        // number of keys per tile
+        //
+        int num_keys1 = static_cast<int>(keys1_end - keys1_beg);
+        int num_keys2 = static_cast<int>(keys2_end - keys2_beg);
+
+
+       // load keys into shared memory for further processing
+        key_type keys_loc[ITEMS_PER_THREAD];
+
+        gmem_to_reg<!IS_LAST_TILE>(keys_loc,
+                                   keys1_in + keys1_beg,
+                                   keys2_in + keys2_beg,
+                                   num_keys1,
+                                   num_keys2);
+
+        reg_to_shared(&storage.load_storage.keys_shared[0], keys_loc);
+
+        sync_threadblock();
+
+        int diag_loc = min<int>(ITEMS_PER_THREAD * threadIdx.x,
+                                num_keys1 + num_keys2);
+
+        pair<int, int> partition_loc =
+            balanced_path(&storage.load_storage.keys_shared[0],
+                          &storage.load_storage.keys_shared[num_keys1],
+                          num_keys1,
+                          num_keys2,
+                          diag_loc,
+                          4,
+                          compare_op);
+
+        int keys1_beg_loc = partition_loc.first;
+        int keys2_beg_loc = partition_loc.second;
+
+        // compute difference between next and current thread
+        // to obtain number of elements per thread
+        int value = threadIdx.x == 0
+                        ? (num_keys1 << 16) | num_keys2
+                        : (partition_loc.first << 16) | partition_loc.second;
+
+        int dst = threadIdx.x == 0 ? BLOCK_THREADS - 1 : threadIdx.x - 1;
+        storage.load_storage.offset[dst] = value;
+
+        core::sync_threadblock();
+
+        pair<int,int> partition1_loc = thrust::make_pair(
+          storage.load_storage.offset[threadIdx.x] >> 16,
+          storage.load_storage.offset[threadIdx.x] & 0xFFFF);
+
+        int keys1_end_loc = partition1_loc.first;
+        int keys2_end_loc = partition1_loc.second;
+
+        int num_keys1_loc = keys1_end_loc - keys1_beg_loc;
+        int num_keys2_loc = keys2_end_loc - keys2_beg_loc;
+
+        // perform serial set operation
+        //
+        int indices[ITEMS_PER_THREAD];
+
+        int active_mask = serial_set_op(&storage.load_storage.keys_shared[0],
+                                        keys1_beg_loc,
+                                        keys2_beg_loc + num_keys1,
+                                        num_keys1_loc,
+                                        num_keys2_loc,
+                                        keys_loc,
+                                        indices,
+                                        compare_op,
+                                        set_op);
+        sync_threadblock();
+#if 0
+        if (ITEMS_PER_THREAD*threadIdx.x >= num_keys1 + num_keys2)
+          active_mask = 0;
+#endif
+
+        // look-back scan over thread_output_count
+        // to compute global thread_output_base and tile_otput_count;
+        Size tile_output_count    = 0;
+        Size thread_output_prefix = 0;
+        Size tile_output_prefix   = 0;
+        Size thread_output_count = static_cast<Size>(__popc(active_mask));
+
+        if (tile_idx == 0)    // first tile
+        {
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(thread_output_count,
+                            thread_output_prefix,
+                            tile_output_count);
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+            {
+              tile_state.SetInclusive(0, tile_output_count);
+            }
+          }
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+
+          BlockScan(storage.scan_storage.scan)
+              .ExclusiveSum(thread_output_count,
+                            thread_output_prefix,
+                            prefix_cb);
+          tile_output_count  = prefix_cb.GetBlockAggregate();
+          tile_output_prefix = prefix_cb.GetExclusivePrefix();
+        }
+
+        sync_threadblock();
+
+        // scatter results
+        //
+        scatter(keys_out,
+                keys_loc,
+                &storage.load_storage.keys_shared[0],
+                active_mask,
+                thread_output_prefix,
+                tile_output_prefix,
+                tile_output_count);
+
+        if (HAS_VALUES::value)
+        {
+          value_type values_loc[ITEMS_PER_THREAD];
+          gmem_to_reg<!IS_LAST_TILE>(values_loc,
+                                     values1_in + keys1_beg,
+                                     values2_in + keys2_beg,
+                                     num_keys1,
+                                     num_keys2);
+
+          sync_threadblock();
+
+          reg_to_shared(&storage.load_storage.values_shared[0], values_loc);
+
+          sync_threadblock();
+
+          // gather items from shared mem
+          //
+#pragma unroll
+          for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+          {
+            if (active_mask & (1 << ITEM))
+            {
+              values_loc[ITEM] = storage.load_storage.values_shared[indices[ITEM]];
+            }
+          }
+
+          sync_threadblock();
+
+          scatter(values_out,
+                  values_loc,
+                  &storage.load_storage.values_shared[0],
+                  active_mask,
+                  thread_output_prefix,
+                  tile_output_prefix,
+                  tile_output_count);
+        }
+
+        if (IS_LAST_TILE && threadIdx.x == 0)
+        {
+          *output_count = tile_output_prefix + tile_output_count;
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &  storage_,
+           ScanTileState &tile_state_,
+           KeysIt1        keys1_,
+           KeysIt2        keys2_,
+           ValuesIt1      values1_,
+           ValuesIt2      values2_,
+           Size           keys1_count_,
+           Size           keys2_count_,
+           KeysOutputIt   keys_out_,
+           ValuesOutputIt values_out_,
+           CompareOp      compare_op_,
+           SetOp          set_op_,
+           pair<Size, Size> *partitions_,
+           std::size_t * output_count_)
+          : storage(storage_),
+            tile_state(tile_state_),
+            keys1_in(core::make_load_iterator(ptx_plan(), keys1_)),
+            keys2_in(core::make_load_iterator(ptx_plan(), keys2_)),
+            values1_in(core::make_load_iterator(ptx_plan(), values1_)),
+            values2_in(core::make_load_iterator(ptx_plan(), values2_)),
+            keys1_count(keys1_count_),
+            keys2_count(keys2_count_),
+            keys_out(keys_out_),
+            values_out(values_out_),
+            compare_op(compare_op_),
+            set_op(set_op_),
+            partitions(partitions_),
+            output_count(output_count_)
+      {
+        int  tile_idx      = blockIdx.x;
+        int  num_tiles     = gridDim.x;
+
+        if (tile_idx < num_tiles-1)
+        {
+          consume_tile<false>(tile_idx);
+        }
+        else
+        {
+          consume_tile<true>(tile_idx);
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysIt1        keys1,
+                       KeysIt2        keys2,
+                       ValuesIt1      values1,
+                       ValuesIt2      values2,
+                       Size           keys1_count,
+                       Size           keys2_count,
+                       KeysOutputIt   keys_output,
+                       ValuesOutputIt values_output,
+                       CompareOp      compare_op,
+                       SetOp          set_op,
+                       pair<Size, Size> *partitions,
+                       std::size_t *  output_count,
+                       ScanTileState tile_state,
+                       char *        shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           keys1,
+           keys2,
+           values1,
+           values2,
+           keys1_count,
+           keys2_count,
+           keys_output,
+           values_output,
+           compare_op,
+           set_op,
+           partitions,
+           output_count);
+    }
+  };    // struct SetOpAgent
+
+  template <class KeysIt1,
+            class KeysIt2,
+            class Size,
+            class CompareOp>
+  struct PartitionAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<256> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeysIt1 keys1,
+                       KeysIt2 keys2,
+                       Size    keys1_count,
+                       Size    keys2_count,
+                       Size    num_partitions,
+                       pair<Size, Size> *partitions,
+                       CompareOp compare_op,
+                       int       items_per_tile,
+                       char * /*shmem*/)
+    {
+      Size partition_idx = blockDim.x * blockIdx.x + threadIdx.x;
+      if (partition_idx < num_partitions)
+      {
+        Size partition_at = min<Size>(partition_idx * items_per_tile,
+                                      keys1_count + keys2_count);
+        pair<Size, Size> diag = balanced_path(keys1,
+                                              keys2,
+                                              keys1_count,
+                                              keys2_count,
+                                              partition_at,
+                                              4ll,
+                                              compare_op);
+        partitions[partition_idx] = diag;
+      }
+    }
+  };    // struct PartitionAgent
+
+  template <class ScanTileState,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+    }
+  }; // struct InitAgent
+
+  //---------------------------------------------------------------------
+  // Serial set operations
+  //---------------------------------------------------------------------
+
+  // serial_set_intersection
+  // -----------------------
+  // emit A if A and B are in range and equal.
+  struct serial_set_intersection
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pA = compare_op(aKey, bKey);
+        bool pB = compare_op(bKey, aKey);
+
+        // The outputs must come from A by definition of set interection.
+        output[i]  = aKey;
+        indices[i] = aBegin;
+
+        if ((aBegin < aEnd) && (bBegin < bEnd) && pA == pB)
+          active_mask |= 1 << i;
+
+        if (!pB) {aKey = keys[++aBegin]; }
+        if (!pA) {bKey = keys[++bBegin]; }
+      }
+      return active_mask;
+    }
+  };    // struct serial_set_intersection
+
+  // serial_set_symmetric_difference
+  // ---------------------
+  // emit A if A < B and emit B if B < A.
+  struct serial_set_symmetric_difference
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // The outputs must come from A by definition of set difference.
+        output[i]  = pA ? aKey : bKey;
+        indices[i] = pA ? aBegin : bBegin;
+
+        if (aBegin + bBegin < end && pA != pB)
+          active_mask |= 1 << i;
+
+        if (!pB) {aKey = keys[++aBegin]; }
+        if (!pA) {bKey = keys[++bBegin]; }
+
+      }
+      return active_mask;
+    }
+  };    // struct set_symmetric_difference
+
+  // serial_set_difference
+  // ---------------------
+  // emit A if A < B
+  struct serial_set_difference
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // The outputs must come from A by definition of set difference.
+        output[i]  = aKey;
+        indices[i] = aBegin;
+
+        if (aBegin + bBegin < end && pA)
+          active_mask |= 1 << i;
+
+        if (!pB) { aKey = keys[++aBegin]; }
+        if (!pA) { bKey = keys[++bBegin]; }
+      }
+      return active_mask;
+    }
+  };    // struct set_difference
+
+  // serial_set_union
+  // ----------------
+  // emit A if A <= B else emit B
+  struct serial_set_union
+  {
+    // max_input_size <= 32
+    template <class T, class CompareOp, int ITEMS_PER_THREAD>
+    int THRUST_DEVICE_FUNCTION
+    operator()(T * keys,
+               int keys1_beg,
+               int keys2_beg,
+               int keys1_count,
+               int keys2_count,
+               T (&output)[ITEMS_PER_THREAD],
+               int (&indices)[ITEMS_PER_THREAD],
+               CompareOp compare_op)
+    {
+      int active_mask = 0;
+
+      int aBegin = keys1_beg;
+      int bBegin = keys2_beg;
+      int aEnd   = keys1_beg + keys1_count;
+      int bEnd   = keys2_beg + keys2_count;
+      int end    = aEnd + bEnd;
+
+      T aKey = keys[aBegin];
+      T bKey = keys[bBegin];
+
+#pragma unroll
+      for (int i = 0; i < ITEMS_PER_THREAD; ++i)
+      {
+        bool pB = aBegin >= aEnd;
+        bool pA = !pB && bBegin >= bEnd;
+
+        if (!pA && !pB)
+        {
+          pA = compare_op(aKey, bKey);
+          pB = !pA && compare_op(bKey, aKey);
+        }
+
+        // Output A in case of a tie, so check if b < a.
+        output[i]  = pB ? bKey : aKey;
+        indices[i] = pB ? bBegin : aBegin;
+
+        if (aBegin + bBegin < end)
+          active_mask |= 1 << i;
+
+        if (!pB) { aKey = keys[++aBegin]; }
+        if (!pA) { bKey = keys[++bBegin]; }
+
+      }
+      return active_mask;
+    }
+  };    // struct set_union
+
+  template <class HAS_VALUES,
+            class KeysIt1,
+            class KeysIt2,
+            class ValuesIt1,
+            class ValuesIt2,
+            class Size,
+            class KeysOutputIt,
+            class ValuesOutputIt,
+            class CompareOp,
+            class SetOp>
+  cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *         d_temp_storage,
+            size_t &       temp_storage_size,
+            KeysIt1        keys1,
+            KeysIt2        keys2,
+            ValuesIt1      values1,
+            ValuesIt2      values2,
+            Size           num_keys1,
+            Size           num_keys2,
+            KeysOutputIt   keys_output,
+            ValuesOutputIt values_output,
+            std::size_t *  output_count,
+            CompareOp      compare_op,
+            SetOp          set_op,
+            cudaStream_t   stream)
+  {
+    Size keys_total = num_keys1 + num_keys2;
+    if (keys_total == 0)
+      return cudaErrorNotSupported;
+
+    cudaError_t status = cudaSuccess;
+
+    using core::AgentPlan;
+    using core::AgentLauncher;
+
+    typedef AgentLauncher<
+        SetOpAgent<KeysIt1,
+                   KeysIt2,
+                   ValuesIt1,
+                   ValuesIt2,
+                   KeysOutputIt,
+                   ValuesOutputIt,
+                   Size,
+                   CompareOp,
+                   SetOp,
+                   HAS_VALUES> >
+        set_op_agent;
+
+    typedef AgentLauncher<PartitionAgent<KeysIt1, KeysIt2, Size, CompareOp> >
+        partition_agent;
+
+    typedef typename set_op_agent::ScanTileState ScanTileState;
+    typedef AgentLauncher<InitAgent<ScanTileState, Size> > init_agent;
+
+
+    AgentPlan set_op_plan    = set_op_agent::get_plan(stream);
+    AgentPlan init_plan      = init_agent::get_plan();
+    AgentPlan partition_plan = partition_agent::get_plan();
+
+    int  tile_size = set_op_plan.items_per_tile;
+    Size num_tiles = (keys_total + tile_size - 1) / tile_size;
+
+    size_t tile_agent_storage;
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles),
+                                           tile_agent_storage);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    size_t vshmem_storage = core::vshmem_size(set_op_plan.shared_memory_size,
+                                              num_tiles);
+    size_t partition_agent_storage = (num_tiles + 1) * sizeof(Size) * 2;
+
+    void *allocations[3] = {NULL, NULL, NULL};
+    size_t allocation_sizes[3] = {tile_agent_storage,
+                                  partition_agent_storage,
+                                  vshmem_storage};
+
+    status = core::alias_storage(d_temp_storage,
+                                 temp_storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_state;
+    status = tile_state.Init(static_cast<int>(num_tiles),
+                             allocations[0],
+                             allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    pair<Size, Size> *partitions = (pair<Size, Size> *)allocations[1];
+    char *vshmem_ptr = vshmem_storage > 0 ? (char *)allocations[2] : NULL;
+
+    init_agent ia(init_plan, num_tiles, stream, "set_op::init_agent");
+    ia.launch(tile_state, num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    partition_agent pa(partition_plan, num_tiles+1, stream, "set_op::partition agent");
+    pa.launch(keys1,
+              keys2,
+              num_keys1,
+              num_keys2,
+              num_tiles+1,
+              partitions,
+              compare_op,
+              tile_size);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    set_op_agent sa(set_op_plan, keys_total, stream, vshmem_ptr, "set_op::set_op_agent");
+    sa.launch(keys1,
+              keys2,
+              values1,
+              values2,
+              num_keys1,
+              num_keys2,
+              keys_output,
+              values_output,
+              compare_op,
+              set_op,
+              partitions,
+              output_count,
+              tile_state);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    return status;
+ }
+
+ template <typename HAS_VALUES,
+           typename Derived,
+           typename KeysIt1,
+           typename KeysIt2,
+           typename ValuesIt1,
+           typename ValuesIt2,
+           typename KeysOutputIt,
+           typename ValuesOutputIt,
+           typename CompareOp,
+           typename SetOp>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeysOutputIt, ValuesOutputIt>
+  set_operations(execution_policy<Derived>& policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ValuesIt1                  values1_first,
+                 ValuesIt2                  values2_first,
+                 KeysOutputIt               keys_output,
+                 ValuesOutputIt             values_output,
+                 CompareOp                  compare_op,
+                 SetOp                      set_op)
+  {
+    typedef typename iterator_traits<KeysIt1>::difference_type size_type;
+
+    size_type num_keys1 = static_cast<size_type>(thrust::distance(keys1_first, keys1_last));
+    size_type num_keys2 = static_cast<size_type>(thrust::distance(keys2_first, keys2_last));
+
+    if (num_keys1 + num_keys2 == 0)
+      return thrust::make_pair(keys_output, values_output);
+
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, doit_step<HAS_VALUES>,
+        num_keys1, num_keys2, (NULL,
+                                   temp_storage_bytes,
+                                   keys1_first,
+                                   keys2_first,
+                                   values1_first,
+                                   values2_first,
+                                   num_keys1_fixed,
+                                   num_keys2_fixed,
+                                   keys_output,
+                                   values_output,
+                                   reinterpret_cast<std::size_t*>(NULL),
+                                   compare_op,
+                                   set_op,
+                                   stream));
+    cuda_cub::throw_on_error(status, "set_operations failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(std::size_t), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "set_operations failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "set_operations failed on 2nd alias_storage");
+
+    std::size_t* d_output_count
+      = thrust::detail::aligned_reinterpret_cast<std::size_t*>(allocations[0]);
+
+    THRUST_DOUBLE_INDEX_TYPE_DISPATCH(status, doit_step<HAS_VALUES>,
+        num_keys1, num_keys2, (allocations[1],
+                                   temp_storage_bytes,
+                                   keys1_first,
+                                   keys2_first,
+                                   values1_first,
+                                   values2_first,
+                                   num_keys1_fixed,
+                                   num_keys2_fixed,
+                                   keys_output,
+                                   values_output,
+                                   d_output_count,
+                                   compare_op,
+                                   set_op,
+                                   stream));
+    cuda_cub::throw_on_error(status, "set_operations failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "set_operations failed to synchronize");
+
+    std::size_t output_count = cuda_cub::get_value(policy, d_output_count);
+
+    return thrust::make_pair(keys_output + output_count, values_output + output_count);
+  }
+}    // namespace __set_operations
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_difference(execution_policy<Derived> &policy,
+               ItemsIt1                   items1_first,
+               ItemsIt1                   items1_last,
+               ItemsIt2                   items2_first,
+               ItemsIt2                   items2_last,
+               OutputIt                   result,
+               CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_difference());
+     result = tmp.first;),
+    (result = thrust::set_difference(cvt_to_seq(derived_cast(policy)),
+                                     items1_first,
+                                     items1_last,
+                                     items2_first,
+                                     items2_last,
+                                     result,
+                                     compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_difference(execution_policy<Derived> &policy,
+               ItemsIt1                   items1_first,
+               ItemsIt1                   items1_last,
+               ItemsIt2                   items2_first,
+               ItemsIt2                   items2_last,
+               OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_difference(policy,
+                                  items1_first,
+                                  items1_last,
+                                  items2_first,
+                                  items2_last,
+                                  result,
+                                  less<value_type>());
+}
+
+/*****************************/
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_intersection(execution_policy<Derived> &policy,
+                 ItemsIt1                   items1_first,
+                 ItemsIt1                   items1_last,
+                 ItemsIt2                   items2_first,
+                 ItemsIt2                   items2_last,
+                 OutputIt                   result,
+                 CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = NULL;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_intersection());
+     result = tmp.first;),
+    (result = thrust::set_intersection(cvt_to_seq(derived_cast(policy)),
+                                       items1_first,
+                                       items1_last,
+                                       items2_first,
+                                       items2_last,
+                                       result,
+                                       compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_intersection(execution_policy<Derived> &policy,
+                 ItemsIt1                   items1_first,
+                 ItemsIt1                   items1_last,
+                 ItemsIt2                   items2_first,
+                 ItemsIt2                   items2_last,
+                 OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_intersection(policy,
+                                    items1_first,
+                                    items1_last,
+                                    items2_first,
+                                    items2_last,
+                                    result,
+                                    less<value_type>());
+}
+
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_symmetric_difference(execution_policy<Derived> &policy,
+                         ItemsIt1                   items1_first,
+                         ItemsIt1                   items1_last,
+                         ItemsIt2                   items2_first,
+                         ItemsIt2                   items2_last,
+                         OutputIt                   result,
+                         CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_symmetric_difference());
+     result = tmp.first;),
+    (result = thrust::set_symmetric_difference(cvt_to_seq(derived_cast(policy)),
+                                               items1_first,
+                                               items1_last,
+                                               items2_first,
+                                               items2_last,
+                                               result,
+                                               compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_symmetric_difference(execution_policy<Derived> &policy,
+                         ItemsIt1                   items1_first,
+                         ItemsIt1                   items1_last,
+                         ItemsIt2                   items2_first,
+                         ItemsIt2                   items2_last,
+                         OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_symmetric_difference(policy,
+                                            items1_first,
+                                            items1_last,
+                                            items2_first,
+                                            items2_last,
+                                            result,
+                                            less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt,
+          class CompareOp>
+OutputIt __host__ __device__
+set_union(execution_policy<Derived> &policy,
+          ItemsIt1                   items1_first,
+          ItemsIt1                   items1_last,
+          ItemsIt2                   items2_first,
+          ItemsIt2                   items2_last,
+          OutputIt                   result,
+          CompareOp                  compare)
+{
+  THRUST_CDP_DISPATCH(
+    (using items1_t  = thrust::iterator_value_t<ItemsIt1>;
+     items1_t *null_ = nullptr;
+     auto tmp = __set_operations::set_operations<thrust::detail::false_type>(
+       policy,
+       items1_first,
+       items1_last,
+       items2_first,
+       items2_last,
+       null_,
+       null_,
+       result,
+       null_,
+       compare,
+       __set_operations::serial_set_union());
+     result = tmp.first;),
+    (result = thrust::set_union(cvt_to_seq(derived_cast(policy)),
+                                items1_first,
+                                items1_last,
+                                items2_first,
+                                items2_last,
+                                result,
+                                compare);));
+  return result;
+}
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2,
+          class OutputIt>
+OutputIt __host__ __device__
+set_union(execution_policy<Derived> &policy,
+          ItemsIt1                   items1_first,
+          ItemsIt1                   items1_last,
+          ItemsIt2                   items2_first,
+          ItemsIt2                   items2_last,
+          OutputIt                   result)
+{
+  typedef typename thrust::iterator_value<ItemsIt1>::type value_type;
+  return cuda_cub::set_union(policy,
+                             items1_first,
+                             items1_last,
+                             items2_first,
+                             items2_last,
+                             result,
+                             less<value_type>());
+}
+
+
+/*****************************/
+/*****************************/
+/*****     *_by_key      *****/
+/*****************************/
+/*****************************/
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_difference_by_key(execution_policy<Derived> &policy,
+                      KeysIt1                    keys1_first,
+                      KeysIt1                    keys1_last,
+                      KeysIt2                    keys2_first,
+                      KeysIt2                    keys2_last,
+                      ItemsIt1                   items1_first,
+                      ItemsIt2                   items2_first,
+                      KeysOutputIt               keys_result,
+                      ItemsOutputIt              items_result,
+                      CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_difference());),
+    (ret = thrust::set_difference_by_key(cvt_to_seq(derived_cast(policy)),
+                                         keys1_first,
+                                         keys1_last,
+                                         keys2_first,
+                                         keys2_last,
+                                         items1_first,
+                                         items2_first,
+                                         keys_result,
+                                         items_result,
+                                         compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_difference_by_key(execution_policy<Derived> &policy,
+                      KeysIt1                    keys1_first,
+                      KeysIt1                    keys1_last,
+                      KeysIt2                    keys2_first,
+                      KeysIt2                    keys2_last,
+                      ItemsIt1                   items1_first,
+                      ItemsIt2                   items2_first,
+                      KeysOutputIt               keys_result,
+                      ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_difference_by_key(policy,
+                                         keys1_first,
+                                         keys1_last,
+                                         keys2_first,
+                                         keys2_last,
+                                         items1_first,
+                                         items2_first,
+                                         keys_result,
+                                         items_result,
+                                         less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_intersection_by_key(execution_policy<Derived> &policy,
+                        KeysIt1                    keys1_first,
+                        KeysIt1                    keys1_last,
+                        KeysIt2                    keys2_first,
+                        KeysIt2                    keys2_last,
+                        ItemsIt1                   items1_first,
+                        KeysOutputIt               keys_result,
+                        ItemsOutputIt              items_result,
+                        CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items1_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_intersection());),
+    (ret = thrust::set_intersection_by_key(cvt_to_seq(derived_cast(policy)),
+                                           keys1_first,
+                                           keys1_last,
+                                           keys2_first,
+                                           keys2_last,
+                                           items1_first,
+                                           keys_result,
+                                           items_result,
+                                           compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_intersection_by_key(execution_policy<Derived> &policy,
+                        KeysIt1                    keys1_first,
+                        KeysIt1                    keys1_last,
+                        KeysIt2                    keys2_first,
+                        KeysIt2                    keys2_last,
+                        ItemsIt1                   items1_first,
+                        KeysOutputIt               keys_result,
+                        ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_intersection_by_key(policy,
+                                           keys1_first,
+                                           keys1_last,
+                                           keys2_first,
+                                           keys2_last,
+                                           items1_first,
+                                           keys_result,
+                                           items_result,
+                                           less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_symmetric_difference_by_key(execution_policy<Derived> &policy,
+                                KeysIt1                    keys1_first,
+                                KeysIt1                    keys1_last,
+                                KeysIt2                    keys2_first,
+                                KeysIt2                    keys2_last,
+                                ItemsIt1                   items1_first,
+                                ItemsIt2                   items2_first,
+                                KeysOutputIt               keys_result,
+                                ItemsOutputIt              items_result,
+                                CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_symmetric_difference());),
+    (ret =
+       thrust::set_symmetric_difference_by_key(cvt_to_seq(derived_cast(policy)),
+                                               keys1_first,
+                                               keys1_last,
+                                               keys2_first,
+                                               keys2_last,
+                                               items1_first,
+                                               items2_first,
+                                               keys_result,
+                                               items_result,
+                                               compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_symmetric_difference_by_key(execution_policy<Derived> &policy,
+                                KeysIt1                    keys1_first,
+                                KeysIt1                    keys1_last,
+                                KeysIt2                    keys2_first,
+                                KeysIt2                    keys2_last,
+                                ItemsIt1                   items1_first,
+                                ItemsIt2                   items2_first,
+                                KeysOutputIt               keys_result,
+                                ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_symmetric_difference_by_key(policy,
+                                                   keys1_first,
+                                                   keys1_last,
+                                                   keys2_first,
+                                                   keys2_last,
+                                                   items1_first,
+                                                   items2_first,
+                                                   keys_result,
+                                                   items_result,
+                                                   less<value_type>());
+}
+
+/*****************************/
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt,
+          class CompareOp>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_union_by_key(execution_policy<Derived> &policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ItemsIt1                   items1_first,
+                 ItemsIt2                   items2_first,
+                 KeysOutputIt               keys_result,
+                 ItemsOutputIt              items_result,
+                 CompareOp                  compare_op)
+{
+  auto ret = thrust::make_pair(keys_result, items_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __set_operations::set_operations<thrust::detail::true_type>(
+       policy,
+       keys1_first,
+       keys1_last,
+       keys2_first,
+       keys2_last,
+       items1_first,
+       items2_first,
+       keys_result,
+       items_result,
+       compare_op,
+       __set_operations::serial_set_union());),
+    (ret = thrust::set_union_by_key(cvt_to_seq(derived_cast(policy)),
+                                    keys1_first,
+                                    keys1_last,
+                                    keys2_first,
+                                    keys2_last,
+                                    items1_first,
+                                    items2_first,
+                                    keys_result,
+                                    items_result,
+                                    compare_op);));
+  return ret;
+}
+
+template <class Derived,
+          class KeysIt1,
+          class KeysIt2,
+          class ItemsIt1,
+          class ItemsIt2,
+          class KeysOutputIt,
+          class ItemsOutputIt>
+pair<KeysOutputIt, ItemsOutputIt> __host__ __device__
+set_union_by_key(execution_policy<Derived> &policy,
+                 KeysIt1                    keys1_first,
+                 KeysIt1                    keys1_last,
+                 KeysIt2                    keys2_first,
+                 KeysIt2                    keys2_last,
+                 ItemsIt1                   items1_first,
+                 ItemsIt2                   items2_first,
+                 KeysOutputIt               keys_result,
+                 ItemsOutputIt              items_result)
+{
+  typedef typename thrust::iterator_value<KeysIt1>::type value_type;
+  return cuda_cub::set_union_by_key(policy,
+                                    keys1_first,
+                                    keys1_last,
+                                    keys2_first,
+                                    keys2_last,
+                                    items1_first,
+                                    items2_first,
+                                    keys_result,
+                                    items_result,
+                                    less<value_type>());
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..db4c211b37703fcc2dc68ca8f971764cef428a41
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/sort.h
@@ -0,0 +1,628 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/distance.h>
+#include <thrust/extrema.h>
+#include <thrust/sequence.h>
+#include <thrust/sort.h>
+
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/core/util.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/integer_math.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/trivial_sequence.h>
+
+#include <thrust/type_traits/is_contiguous_iterator.h>
+
+#include <cub/device/device_radix_sort.cuh>
+#include <cub/device/device_merge_sort.cuh>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __merge_sort {
+
+  template <class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void*        d_temp_storage,
+            size_t&      temp_storage_bytes,
+            KeysIt       keys,
+            ItemsIt      ,
+            Size         keys_count,
+            CompareOp    compare_op,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, false> /* sort_keys */)
+  {
+    using ItemsInputIt = cub::NullType *;
+    ItemsInputIt items = nullptr;
+
+    using DispatchMergeSortT = cub::DispatchMergeSort<KeysIt,
+                                                      ItemsInputIt,
+                                                      KeysIt,
+                                                      ItemsInputIt,
+                                                      Size,
+                                                      CompareOp>;
+
+
+    return DispatchMergeSortT::Dispatch(d_temp_storage,
+                                        temp_storage_bytes,
+                                        keys,
+                                        items,
+                                        keys,
+                                        items,
+                                        keys_count,
+                                        compare_op,
+                                        stream);
+  }
+
+  template <class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            KeysIt keys,
+            ItemsIt items,
+            Size keys_count,
+            CompareOp compare_op,
+            cudaStream_t stream,
+            thrust::detail::integral_constant<bool, true> /* sort_items */)
+  {
+    using DispatchMergeSortT =
+      cub::DispatchMergeSort<KeysIt, ItemsIt, KeysIt, ItemsIt, Size, CompareOp>;
+
+    return DispatchMergeSortT::Dispatch(d_temp_storage,
+                                        temp_storage_bytes,
+                                        keys,
+                                        items,
+                                        keys,
+                                        items,
+                                        keys_count,
+                                        compare_op,
+                                        stream);
+  }
+
+  template <class SORT_ITEMS,
+            class /* STABLE */,
+            class KeysIt,
+            class ItemsIt,
+            class Size,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION cudaError_t
+  doit_step(void *d_temp_storage,
+            size_t &temp_storage_bytes,
+            KeysIt keys,
+            ItemsIt items,
+            Size keys_count,
+            CompareOp compare_op,
+            cudaStream_t stream)
+  {
+    if (keys_count == 0)
+    {
+      return cudaSuccess;
+    }
+
+    thrust::detail::integral_constant<bool, SORT_ITEMS::value> sort_items{};
+
+    return doit_step(d_temp_storage,
+                     temp_storage_bytes,
+                     keys,
+                     items,
+                     keys_count,
+                     compare_op,
+                     stream,
+                     sort_items);
+  }
+
+  template <typename SORT_ITEMS,
+            typename STABLE,
+            typename Derived,
+            typename KeysIt,
+            typename ItemsIt,
+            typename CompareOp>
+  THRUST_RUNTIME_FUNCTION
+  void merge_sort(execution_policy<Derived>& policy,
+                  KeysIt                     keys_first,
+                  KeysIt                     keys_last,
+                  ItemsIt                    items_first,
+                  CompareOp                  compare_op)
+
+  {
+    typedef typename iterator_traits<KeysIt>::difference_type size_type;
+
+    size_type count = static_cast<size_type>(thrust::distance(keys_first, keys_last));
+
+    size_t       storage_size = 0;
+    cudaStream_t stream       = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step<SORT_ITEMS, STABLE>(NULL,
+                                           storage_size,
+                                           keys_first,
+                                           items_first,
+                                           count,
+                                           compare_op,
+                                           stream);
+    cuda_cub::throw_on_error(status, "merge_sort: failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = doit_step<SORT_ITEMS, STABLE>(ptr,
+                                           storage_size,
+                                           keys_first,
+                                           items_first,
+                                           count,
+                                           compare_op,
+                                           stream);
+    cuda_cub::throw_on_error(status, "merge_sort: failed on 2nd step");
+
+    status = cuda_cub::synchronize_optional(policy);
+    cuda_cub::throw_on_error(status, "merge_sort: failed to synchronize");
+  }
+}    // namespace __merge_sort
+
+namespace __radix_sort {
+
+  template <class SORT_ITEMS, class Comparator>
+  struct dispatch;
+
+  // sort keys in ascending order
+  template <class K>
+  struct dispatch<thrust::detail::false_type, thrust::less<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& /*items_buffer*/,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortKeys(d_temp_storage,
+                                            temp_storage_bytes,
+                                            keys_buffer,
+                                            static_cast<int>(count),
+                                            0,
+                                            static_cast<int>(sizeof(Key) * 8),
+                                            stream);
+    }
+  }; // struct dispatch -- sort keys in ascending order;
+
+  // sort keys in descending order
+  template <class K>
+  struct dispatch<thrust::detail::false_type, thrust::greater<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& /*items_buffer*/,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortKeysDescending(d_temp_storage,
+                                                      temp_storage_bytes,
+                                                      keys_buffer,
+                                                      static_cast<int>(count),
+                                                      0,
+                                                      static_cast<int>(sizeof(Key) * 8),
+                                                      stream);
+    }
+  }; // struct dispatch -- sort keys in descending order;
+
+  // sort pairs in ascending order
+  template <class K>
+  struct dispatch<thrust::detail::true_type, thrust::less<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& items_buffer,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortPairs(d_temp_storage,
+                                             temp_storage_bytes,
+                                             keys_buffer,
+                                             items_buffer,
+                                             static_cast<int>(count),
+                                             0,
+                                             static_cast<int>(sizeof(Key) * 8),
+                                             stream);
+    }
+  }; // struct dispatch -- sort pairs in ascending order;
+
+  // sort pairs in descending order
+  template <class K>
+  struct dispatch<thrust::detail::true_type, thrust::greater<K> >
+  {
+    template <class Key, class Item, class Size>
+    THRUST_RUNTIME_FUNCTION static cudaError_t
+    doit(void*                    d_temp_storage,
+         size_t&                  temp_storage_bytes,
+         cub::DoubleBuffer<Key>&  keys_buffer,
+         cub::DoubleBuffer<Item>& items_buffer,
+         Size                     count,
+         cudaStream_t             stream)
+    {
+      return cub::DeviceRadixSort::SortPairsDescending(d_temp_storage,
+                                                       temp_storage_bytes,
+                                                       keys_buffer,
+                                                       items_buffer,
+                                                       static_cast<int>(count),
+                                                       0,
+                                                       static_cast<int>(sizeof(Key) * 8),
+                                                       stream);
+    }
+  }; // struct dispatch -- sort pairs in descending order;
+
+  template <typename SORT_ITEMS,
+            typename Derived,
+            typename Key,
+            typename Item,
+            typename Size,
+            typename CompareOp>
+  THRUST_RUNTIME_FUNCTION
+  void radix_sort(execution_policy<Derived>& policy,
+                  Key*                       keys,
+                  Item*                      items,
+                  Size                       count,
+                  CompareOp)
+  {
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cub::DoubleBuffer<Key>  keys_buffer(keys, NULL);
+    cub::DoubleBuffer<Item> items_buffer(items, NULL);
+
+    Size keys_count = count;
+    Size items_count = SORT_ITEMS::value ? count : 0;
+
+    cudaError_t status;
+
+    status = dispatch<SORT_ITEMS, CompareOp>::doit(NULL,
+                                                   temp_storage_bytes,
+                                                   keys_buffer,
+                                                   items_buffer,
+                                                   keys_count,
+                                                   stream);
+    cuda_cub::throw_on_error(status, "radix_sort: failed on 1st step");
+
+    size_t keys_temp_storage  = core::align_to(sizeof(Key) * keys_count, 128);
+    size_t items_temp_storage = core::align_to(sizeof(Item) * items_count, 128);
+
+    size_t storage_size = keys_temp_storage
+                        + items_temp_storage
+                        + temp_storage_bytes;
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+
+    keys_buffer.d_buffers[1]  = thrust::detail::aligned_reinterpret_cast<Key*>(
+      tmp.data().get()
+    );
+    items_buffer.d_buffers[1] = thrust::detail::aligned_reinterpret_cast<Item*>(
+      tmp.data().get() + keys_temp_storage
+    );
+    void *ptr = static_cast<void*>(
+      tmp.data().get() + keys_temp_storage + items_temp_storage
+    );
+
+    status = dispatch<SORT_ITEMS, CompareOp>::doit(ptr,
+                                                   temp_storage_bytes,
+                                                   keys_buffer,
+                                                   items_buffer,
+                                                   keys_count,
+                                                   stream);
+    cuda_cub::throw_on_error(status, "radix_sort: failed on 2nd step");
+
+    if (keys_buffer.selector != 0)
+    {
+      Key* temp_ptr = reinterpret_cast<Key*>(keys_buffer.d_buffers[1]);
+      cuda_cub::copy_n(policy, temp_ptr, keys_count, keys);
+    }
+    THRUST_IF_CONSTEXPR(SORT_ITEMS::value)
+    {
+      if (items_buffer.selector != 0)
+      {
+        Item *temp_ptr = reinterpret_cast<Item *>(items_buffer.d_buffers[1]);
+        cuda_cub::copy_n(policy, temp_ptr, items_count, items);
+      }
+    }
+  }
+}    // __radix_sort
+
+//---------------------------------------------------------------------
+// Smart sort picks at compile-time whether to dispatch radix or merge sort
+//---------------------------------------------------------------------
+
+namespace __smart_sort {
+
+  template <class Key, class CompareOp>
+  struct can_use_primitive_sort
+      : thrust::detail::and_<
+            thrust::detail::is_arithmetic<Key>,
+            thrust::detail::or_<
+                thrust::detail::is_same<CompareOp, thrust::less<Key> >,
+                thrust::detail::is_same<CompareOp, thrust::greater<Key> > > > {};
+
+  template <class Iterator, class CompareOp>
+  struct enable_if_primitive_sort
+      : thrust::detail::enable_if<
+            can_use_primitive_sort<typename iterator_value<Iterator>::type,
+                                   CompareOp>::value> {};
+
+  template <class Iterator, class CompareOp>
+  struct enable_if_comparison_sort
+      : thrust::detail::disable_if<
+            can_use_primitive_sort<typename iterator_value<Iterator>::type,
+                                   CompareOp>::value> {};
+
+
+  template <class SORT_ITEMS,
+            class STABLE,
+            class Policy,
+            class KeysIt,
+            class ItemsIt,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION typename enable_if_comparison_sort<KeysIt, CompareOp>::type
+  smart_sort(Policy&   policy,
+             KeysIt    keys_first,
+             KeysIt    keys_last,
+             ItemsIt   items_first,
+             CompareOp compare_op)
+  {
+    __merge_sort::merge_sort<SORT_ITEMS, STABLE>(policy,
+                                                 keys_first,
+                                                 keys_last,
+                                                 items_first,
+                                                 compare_op);
+
+  }
+
+  template <class SORT_ITEMS,
+            class STABLE,
+            class Policy,
+            class KeysIt,
+            class ItemsIt,
+            class CompareOp>
+  THRUST_RUNTIME_FUNCTION typename enable_if_primitive_sort<KeysIt, CompareOp>::type
+  smart_sort(execution_policy<Policy>& policy,
+             KeysIt                    keys_first,
+             KeysIt                    keys_last,
+             ItemsIt                   items_first,
+             CompareOp                 compare_op)
+  {
+    // ensure sequences have trivial iterators
+    thrust::detail::trivial_sequence<KeysIt, Policy>
+        keys(policy, keys_first, keys_last);
+
+    if (SORT_ITEMS::value)
+    {
+      thrust::detail::trivial_sequence<ItemsIt, Policy>
+          values(policy, items_first, items_first + (keys_last - keys_first));
+
+      __radix_sort::radix_sort<SORT_ITEMS>(
+          policy,
+          thrust::raw_pointer_cast(&*keys.begin()),
+          thrust::raw_pointer_cast(&*values.begin()),
+          keys_last - keys_first,
+          compare_op);
+
+      if (!is_contiguous_iterator<ItemsIt>::value)
+      {
+        cuda_cub::copy(policy, values.begin(), values.end(), items_first);
+      }
+    }
+    else
+    {
+      __radix_sort::radix_sort<SORT_ITEMS>(
+          policy,
+          thrust::raw_pointer_cast(&*keys.begin()),
+          thrust::raw_pointer_cast(&*keys.begin()),
+          keys_last - keys_first,
+          compare_op);
+    }
+
+    // copy results back, if necessary
+    if (!is_contiguous_iterator<KeysIt>::value)
+    {
+      cuda_cub::copy(policy, keys.begin(), keys.end(), keys_first);
+    }
+
+    cuda_cub::throw_on_error(
+      cuda_cub::synchronize_optional(policy),
+      "smart_sort: failed to synchronize");
+  }
+}    // namespace __smart_sort
+
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+
+__thrust_exec_check_disable__
+template <class Derived, class ItemsIt, class CompareOp>
+void __host__ __device__
+sort(execution_policy<Derived>& policy,
+     ItemsIt                    first,
+     ItemsIt                    last,
+     CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (using item_t = thrust::iterator_value_t<ItemsIt>; item_t *null_ = nullptr;
+     __smart_sort::smart_sort<thrust::detail::false_type,
+                              thrust::detail::false_type>(policy,
+                                                          first,
+                                                          last,
+                                                          null_,
+                                                          compare_op);),
+    (thrust::sort(cvt_to_seq(derived_cast(policy)), first, last, compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived, class ItemsIt, class CompareOp>
+void __host__ __device__
+stable_sort(execution_policy<Derived>& policy,
+            ItemsIt                    first,
+            ItemsIt                    last,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (using item_t = thrust::iterator_value_t<ItemsIt>; item_t *null_ = nullptr;
+     __smart_sort::smart_sort<thrust::detail::false_type,
+                              thrust::detail::true_type>(policy,
+                                                         first,
+                                                         last,
+                                                         null_,
+                                                         compare_op);),
+    (thrust::stable_sort(cvt_to_seq(derived_cast(policy)),
+                         first,
+                         last,
+                         compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived, class KeysIt, class ValuesIt, class CompareOp>
+void __host__ __device__
+sort_by_key(execution_policy<Derived>& policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (__smart_sort::smart_sort<thrust::detail::true_type,
+                              thrust::detail::false_type>(policy,
+                                                          keys_first,
+                                                          keys_last,
+                                                          values,
+                                                          compare_op);),
+    (thrust::sort_by_key(cvt_to_seq(derived_cast(policy)),
+                         keys_first,
+                         keys_last,
+                         values,
+                         compare_op);));
+}
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeysIt,
+          class ValuesIt,
+          class CompareOp>
+void __host__ __device__
+stable_sort_by_key(execution_policy<Derived> &policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values,
+            CompareOp                  compare_op)
+{
+  THRUST_CDP_DISPATCH(
+    (__smart_sort::smart_sort<thrust::detail::true_type,
+                              thrust::detail::true_type>(policy,
+                                                         keys_first,
+                                                         keys_last,
+                                                         values,
+                                                         compare_op);),
+    (thrust::stable_sort_by_key(cvt_to_seq(derived_cast(policy)),
+                                keys_first,
+                                keys_last,
+                                values,
+                                compare_op);));
+}
+
+// API with default comparator
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+sort(execution_policy<Derived>& policy,
+     ItemsIt                    first,
+     ItemsIt                    last)
+{
+  typedef typename thrust::iterator_value<ItemsIt>::type item_type;
+  cuda_cub::sort(policy, first, last, less<item_type>());
+}
+
+template <class Derived, class ItemsIt>
+void __host__ __device__
+stable_sort(execution_policy<Derived>& policy,
+            ItemsIt                    first,
+            ItemsIt                    last)
+{
+  typedef typename thrust::iterator_value<ItemsIt>::type item_type;
+  cuda_cub::stable_sort(policy, first, last, less<item_type>());
+}
+
+template <class Derived, class KeysIt, class ValuesIt>
+void __host__ __device__
+sort_by_key(execution_policy<Derived>& policy,
+            KeysIt                     keys_first,
+            KeysIt                     keys_last,
+            ValuesIt                   values)
+{
+  typedef typename thrust::iterator_value<KeysIt>::type key_type;
+  cuda_cub::sort_by_key(policy, keys_first, keys_last, values, less<key_type>());
+}
+
+template <class Derived, class KeysIt, class ValuesIt>
+void __host__ __device__
+stable_sort_by_key(
+    execution_policy<Derived>& policy, KeysIt keys_first, KeysIt keys_last, ValuesIt values)
+{
+  typedef typename thrust::iterator_value<KeysIt>::type key_type;
+  cuda_cub::stable_sort_by_key(policy, keys_first, keys_last, values, less<key_type>());
+}
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/swap_ranges.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/swap_ranges.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f9e4fa8aafaf8cd199ba57d57edd21f5f78d2f0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/swap_ranges.h
@@ -0,0 +1,102 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/swap.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __swap_ranges {
+
+
+  template <class ItemsIt1, class ItemsIt2>
+  struct swap_f
+  {
+    ItemsIt1 items1;
+    ItemsIt2 items2;
+
+    typedef  typename iterator_traits<ItemsIt1>::value_type value1_type;
+    typedef  typename iterator_traits<ItemsIt2>::value_type value2_type;
+
+    THRUST_FUNCTION
+    swap_f(ItemsIt1 items1_, ItemsIt2 items2_)
+        : items1(items1_), items2(items2_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      value1_type item1 = items1[idx];
+      value2_type item2 = items2[idx];
+      // XXX thrust::swap is buggy
+      // if reference_type of ItemIt1/ItemsIt2
+      // is a proxy reference, then KABOOM!
+      // to avoid this, just copy the value first before swap
+      // *todo* specialize on real & proxy references
+      using thrust::swap;
+      swap(item1, item2);
+      items1[idx] = item1;
+      items2[idx] = item2;
+    }
+  };
+}    // namespace __swap_ranges
+
+template <class Derived,
+          class ItemsIt1,
+          class ItemsIt2>
+ItemsIt2 __host__ __device__
+swap_ranges(execution_policy<Derived> &policy,
+            ItemsIt1                   first1,
+            ItemsIt1                   last1,
+            ItemsIt2                   first2)
+{
+  typedef typename iterator_traits<ItemsIt1>::difference_type size_type;
+
+  size_type num_items = static_cast<size_type>(thrust::distance(first1, last1));
+
+  cuda_cub::parallel_for(policy,
+                         __swap_ranges::swap_f<ItemsIt1,
+                                               ItemsIt2>(first1, first2),
+                         num_items);
+
+  return first2 + num_items;
+}
+
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/tabulate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/tabulate.h
new file mode 100644
index 0000000000000000000000000000000000000000..67edb8574d4f0701d23f8e30c100b8e776f962c5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/tabulate.h
@@ -0,0 +1,83 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/distance.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/execution_policy.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+namespace __tabulate {
+
+  template <class Iterator, class TabulateOp, class Size>
+  struct functor
+  {
+    Iterator items;
+    TabulateOp op;
+
+    __host__ __device__
+    functor(Iterator items_, TabulateOp op_)
+        : items(items_), op(op_) {}
+
+    void __device__ operator()(Size idx)
+    {
+      items[idx] = op(idx);
+    }
+  };    // struct functor
+
+}    // namespace __tabulate
+
+template <class Derived,
+          class Iterator,
+          class TabulateOp>
+void __host__ __device__
+tabulate(execution_policy<Derived>& policy,
+         Iterator                   first,
+         Iterator                   last,
+         TabulateOp                 tabulate_op)
+{
+  typedef typename iterator_traits<Iterator>::difference_type size_type;
+
+  size_type count = thrust::distance(first, last);
+
+  typedef __tabulate::functor<Iterator, TabulateOp, size_type> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, tabulate_op),
+                         count);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/temporary_buffer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/temporary_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b5276141625d61567d3adb06a363682b4df968b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/temporary_buffer.h
@@ -0,0 +1,22 @@
+/*
+ *  Copyright 2008-2016 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>
+
+// this system has no special temporary buffer functions
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/terminate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/terminate.h
new file mode 100644
index 0000000000000000000000000000000000000000..226c9d5ac2a71109107c0af2fb0d0a69300b10c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/terminate.h
@@ -0,0 +1,62 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <cstdio>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace cuda
+{
+namespace detail
+{
+
+
+inline __device__
+void terminate()
+{
+  thrust::cuda_cub::terminate();
+}
+
+
+inline __host__ __device__
+void terminate_with_message(const char* message)
+{
+  printf("%s\n", message);
+  thrust::cuda_cub::terminate();
+}
+
+
+} // end detail
+} // end cuda
+} // end system
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cf171a472431656057904387d396a9318964c5d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform.h
@@ -0,0 +1,416 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <thrust/system/cuda/config.h>
+
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+
+namespace __transform {
+
+  struct no_stencil_tag
+  {
+  };
+
+  struct always_true_predicate
+  {
+    template <class T>
+    bool THRUST_DEVICE_FUNCTION operator()(T const &) const
+    {
+      return true;
+    }
+  };
+
+  template <class InputIt,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  struct unary_transform_f
+  {
+    InputIt     input;
+    OutputIt    output;
+    StencilIt   stencil;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    unary_transform_f(InputIt     input_,
+                      OutputIt    output_,
+                      StencilIt   stencil_,
+                      TransformOp op_,
+                      Predicate   pred_)
+        : input(input_),
+          output(output_),
+          stencil(stencil_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(stencil[idx])))
+        output[idx] = op(raw_reference_cast(input[idx]));
+    }
+  }; // struct unary_transform_stencil_f
+
+  template <class InputIt,
+            class OutputIt,
+            class TransformOp,
+            class Predicate>
+  struct unary_transform_f<InputIt,
+                           OutputIt,
+                           no_stencil_tag,
+                           TransformOp,
+                           Predicate>
+  {
+    InputIt     input;
+    OutputIt    output;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    unary_transform_f(InputIt        input_,
+                      OutputIt       output_,
+                      no_stencil_tag,
+                      TransformOp    op_,
+                      Predicate      pred_)
+        : input(input_), output(output_), op(op_), pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(input[idx])))
+        output[idx] = op(raw_reference_cast(input[idx]));
+    }
+  }; // struct unary_transform_f
+
+  template <class InputIt1,
+            class InputIt2,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  struct binary_transform_f
+  {
+    InputIt1    input1;
+    InputIt2    input2;
+    OutputIt    output;
+    StencilIt   stencil;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    binary_transform_f(InputIt1    input1_,
+                       InputIt2    input2_,
+                       OutputIt    output_,
+                       StencilIt   stencil_,
+                       TransformOp op_,
+                       Predicate   pred_)
+        : input1(input1_),
+          input2(input2_),
+          output(output_),
+          stencil(stencil_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(stencil[idx])))
+        output[idx] = op(raw_reference_cast(input1[idx]),
+                         raw_reference_cast(input2[idx]));
+    }
+  }; // struct binary_transform_stencil_f
+
+  template <class InputIt1,
+            class InputIt2,
+            class OutputIt,
+            class TransformOp,
+            class Predicate>
+  struct binary_transform_f<InputIt1,
+                            InputIt2,
+                            OutputIt,
+                            no_stencil_tag,
+                            TransformOp,
+                            Predicate>
+  {
+    InputIt1    input1;
+    InputIt2    input2;
+    OutputIt    output;
+    TransformOp op;
+    Predicate   pred;
+
+    THRUST_FUNCTION
+    binary_transform_f(InputIt1       input1_,
+                       InputIt2       input2_,
+                       OutputIt       output_,
+                       no_stencil_tag ,
+                       TransformOp    op_,
+                       Predicate      pred_)
+        : input1(input1_),
+          input2(input2_),
+          output(output_),
+          op(op_),
+          pred(pred_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      if (pred(raw_reference_cast(input1[idx])))
+        output[idx] = op(raw_reference_cast(input1[idx]),
+                         raw_reference_cast(input2[idx]));
+    }
+  }; // struct binary_transform_f
+
+  template <class Policy,
+            class InputIt,
+            class Size,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  OutputIt THRUST_FUNCTION
+  unary(Policy &     policy,
+        InputIt      items,
+        OutputIt     result,
+        Size         num_items,
+        StencilIt    stencil,
+        TransformOp  transform_op,
+        Predicate    predicate)
+  {
+    if (num_items == 0)
+      return result;
+
+    typedef unary_transform_f<InputIt,
+                              OutputIt,
+                              StencilIt,
+                              TransformOp,
+                              Predicate>
+        unary_transform_t;
+
+    cuda_cub::parallel_for(policy,
+                           unary_transform_t(items,
+                                             result,
+                                             stencil,
+                                             transform_op,
+                                             predicate),
+                           num_items);
+
+    return result + num_items;
+  }
+
+  template <class Policy,
+            class InputIt1,
+            class InputIt2,
+            class Size,
+            class OutputIt,
+            class StencilIt,
+            class TransformOp,
+            class Predicate>
+  OutputIt THRUST_FUNCTION
+  binary(Policy &    policy,
+         InputIt1    items1,
+         InputIt2    items2,
+         OutputIt    result,
+         Size        num_items,
+         StencilIt   stencil,
+         TransformOp transform_op,
+         Predicate   predicate)
+  {
+    if (num_items == 0)
+      return result;
+
+    typedef binary_transform_f<InputIt1,
+                               InputIt2,
+                               OutputIt,
+                               StencilIt,
+                               TransformOp,
+                               Predicate>
+        binary_transform_t;
+
+    cuda_cub::parallel_for(policy,
+                           binary_transform_t(items1,
+                                              items2,
+                                              result,
+                                              stencil,
+                                              transform_op,
+                                              predicate),
+                           num_items);
+
+    return result + num_items;
+  }
+
+}    // namespace __transform
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+//-------------------------
+//  one input data stream
+//-------------------------
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class StencilInputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             StencilInputIt             stencil,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  return __transform::unary(policy,
+                            first,
+                            result,
+                            num_items,
+                            stencil,
+                            transform_op,
+                            predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt                    first,
+             InputIt                    last,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  return cuda_cub::transform_if(policy,
+                                first,
+                                last,
+                                __transform::no_stencil_tag(),
+                                result,
+                                transform_op,
+                                predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp>
+OutputIt THRUST_FUNCTION
+transform(execution_policy<Derived> &policy,
+          InputIt                    first,
+          InputIt                    last,
+          OutputIt                   result,
+          TransformOp                transform_op)
+{
+  return cuda_cub::transform_if(policy,
+                                first,
+                                last,
+                                result,
+                                transform_op,
+                                __transform::always_true_predicate());
+} // func transform
+
+//-------------------------
+// two input data streams
+//-------------------------
+
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class StencilInputIt,
+          class OutputIt,
+          class TransformOp,
+          class Predicate>
+OutputIt THRUST_FUNCTION
+transform_if(execution_policy<Derived> &policy,
+             InputIt1                   first1,
+             InputIt1                   last1,
+             InputIt2                   first2,
+             StencilInputIt             stencil,
+             OutputIt                   result,
+             TransformOp                transform_op,
+             Predicate                  predicate)
+{
+  typedef typename iterator_traits<InputIt1>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first1, last1));
+  return __transform::binary(policy,
+                             first1,
+                             first2,
+                             result,
+                             num_items,
+                             stencil,
+                             transform_op,
+                             predicate);
+}    // func transform_if
+
+template <class Derived,
+          class InputIt1,
+          class InputIt2,
+          class OutputIt,
+          class TransformOp>
+OutputIt THRUST_FUNCTION
+transform(execution_policy<Derived> &policy,
+          InputIt1                   first1,
+          InputIt1                   last1,
+          InputIt2                   first2,
+          OutputIt                   result,
+          TransformOp                transform_op)
+{
+  return cuda_cub::transform_if(policy,
+                                first1,
+                                last1,
+                                first2,
+                                __transform::no_stencil_tag(),
+                                result,
+                                transform_op,
+                                __transform::always_true_predicate());
+} // func transform
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..60efaae5a5526c48210762bcac7f1ffef48b8aa7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_reduce.h
@@ -0,0 +1,68 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/distance.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class TransformOp,
+          class T,
+          class ReduceOp>
+T __host__ __device__
+transform_reduce(execution_policy<Derived> &policy,
+                 InputIt                    first,
+                 InputIt                    last,
+                 TransformOp                transform_op,
+                 T                          init,
+                 ReduceOp                   reduce_op)
+{
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<T,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::reduce_n(policy,
+                            transformed_iterator_t(first, transform_op),
+                            num_items,
+                            init,
+                            reduce_op);
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f14ca8f7f20fd9f769f7dd72a85127ff1b8a047
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/transform_scan.h
@@ -0,0 +1,109 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/detail/type_traits.h>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/scan.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class ScanOp>
+OutputIt __host__ __device__
+transform_inclusive_scan(execution_policy<Derived> &policy,
+                         InputIt                    first,
+                         InputIt                    last,
+                         OutputIt                   result,
+                         TransformOp                transform_op,
+                         ScanOp                     scan_op)
+{
+  // Use the transformed input iterator's value type per https://wg21.link/P0571
+  using input_type = typename thrust::iterator_value<InputIt>::type;
+  using result_type = thrust::detail::invoke_result_t<TransformOp, input_type>;
+  using value_type = thrust::remove_cvref_t<result_type>;
+
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<value_type,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::inclusive_scan_n(policy,
+                                 transformed_iterator_t(first, transform_op),
+                                 num_items,
+                                 result,
+                                 scan_op);
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class TransformOp,
+          class InitialValueType,
+          class ScanOp>
+OutputIt __host__ __device__
+transform_exclusive_scan(execution_policy<Derived> &policy,
+                         InputIt                    first,
+                         InputIt                    last,
+                         OutputIt                   result,
+                         TransformOp                transform_op,
+                         InitialValueType           init,
+                         ScanOp                     scan_op)
+{
+  // Use the initial value type per https://wg21.link/P0571
+  using result_type = thrust::remove_cvref_t<InitialValueType>;
+
+  typedef typename iterator_traits<InputIt>::difference_type size_type;
+  size_type num_items = static_cast<size_type>(thrust::distance(first, last));
+  typedef transform_input_iterator_t<result_type,
+                                     InputIt,
+                                     TransformOp>
+      transformed_iterator_t;
+
+  return cuda_cub::exclusive_scan_n(policy,
+                                 transformed_iterator_t(first, transform_op),
+                                 num_items,
+                                 result,
+                                 init,
+                                 scan_op);
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..f21b7c0d62ff3b0a5970617892c52ddd276d18b7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_copy.h
@@ -0,0 +1,111 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __uninitialized_copy {
+
+  template <class InputIt, class OutputIt>
+  struct functor
+  {
+    InputIt  input;
+    OutputIt output;
+
+    typedef typename iterator_traits<InputIt>::value_type  InputType;
+    typedef typename iterator_traits<OutputIt>::value_type OutputType;
+
+    THRUST_FUNCTION
+    functor(InputIt input_, OutputIt output_)
+        : input(input_), output(output_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      InputType const &in  = raw_reference_cast(input[idx]);
+      OutputType &     out = raw_reference_cast(output[idx]);
+
+#if defined(__CUDA__) && defined(__clang__)
+      // XXX unsafe, but clang is seemngly unable to call in-place new
+      out = in;
+#else
+      ::new (static_cast<void *>(&out)) OutputType(in);
+#endif
+    }
+  };    // struct functor
+
+}    // namespace __uninitialized_copy
+
+template <class Derived,
+          class InputIt,
+          class Size,
+          class OutputIt>
+OutputIt __host__ __device__
+uninitialized_copy_n(execution_policy<Derived> &policy,
+                     InputIt                    first,
+                     Size                       count,
+                     OutputIt                   result)
+{
+  typedef __uninitialized_copy::functor<InputIt,OutputIt> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, result),
+                         count);
+
+  return result + count;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+uninitialized_copy(execution_policy<Derived>& policy,
+                   InputIt                    first,
+                   InputIt                    last,
+                   OutputIt                   result)
+{
+  return cuda_cub::uninitialized_copy_n(policy,
+                                        first,
+                                        thrust::distance(first, last),
+                                        result);
+}
+
+}    // namespace cuda_
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..96b9702016b914bf12d6254cd6fcde4c77e545ce
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/uninitialized_fill.h
@@ -0,0 +1,109 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#include <iterator>
+#include <thrust/distance.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/util.h>
+#include <thrust/system/cuda/detail/parallel_for.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace cuda_cub {
+
+namespace __uninitialized_fill {
+
+  template <class Iterator, class T>
+  struct functor
+  {
+    Iterator  items;
+    T         value;
+
+    typedef typename iterator_traits<Iterator>::value_type value_type;
+
+    THRUST_FUNCTION
+    functor(Iterator items_, T const& value_)
+        : items(items_), value(value_) {}
+
+    template<class Size>
+    void THRUST_DEVICE_FUNCTION operator()(Size idx)
+    {
+      value_type& out = raw_reference_cast(items[idx]);
+
+#if defined(__CUDA__) && defined(__clang__)
+      // XXX unsafe. cuda-clang is seemingly unable to call ::new in device code
+      out = value;
+#else
+      ::new (static_cast<void *>(&out)) value_type(value);
+#endif
+    }
+  };    // struct functor
+
+}    // namespace __uninitialized_copy
+
+template <class Derived,
+          class Iterator,
+          class Size,
+          class T>
+Iterator __host__ __device__
+uninitialized_fill_n(execution_policy<Derived>& policy,
+                     Iterator                   first,
+                     Size                       count,
+                     T const&                   x)
+{
+  typedef __uninitialized_fill::functor<Iterator,T> functor_t;
+
+  cuda_cub::parallel_for(policy,
+                         functor_t(first, x),
+                         count);
+
+  return first + count;
+}
+
+template <class Derived,
+          class Iterator,
+          class T>
+void __host__ __device__
+uninitialized_fill(execution_policy<Derived>& policy,
+                   Iterator                   first,
+                   Iterator                   last,
+                   T const&                   x)
+{
+  cuda_cub::uninitialized_fill_n(policy,
+                              first,
+                              thrust::distance(first, last),
+                              x);
+}
+
+}    // namespace cuda_cub
+
+THRUST_NAMESPACE_END
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique.h
new file mode 100644
index 0000000000000000000000000000000000000000..653ffa79ab6aadd14c03a790aefc2ae949b951d0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique.h
@@ -0,0 +1,821 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/advance.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__ ForwardIterator
+unique(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator                                             first,
+    ForwardIterator                                             last,
+    BinaryPredicate                                             binary_pred);
+
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename BinaryPredicate>
+__host__ __device__ OutputIterator
+unique_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator                                               first,
+    InputIterator                                               last,
+    OutputIterator                                              result,
+    BinaryPredicate                                             binary_pred);
+
+template <typename DerivedPolicy,
+          typename ForwardIterator,
+          typename BinaryPredicate>
+__host__ __device__ typename thrust::iterator_traits<ForwardIterator>::difference_type
+unique_count(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator                                             first,
+    ForwardIterator                                             last,
+    BinaryPredicate                                             binary_pred);
+
+namespace cuda_cub {
+
+// XXX  it should be possible to unify unique & unique_by_key into a single
+//      agent with various specializations, similar to what is done
+//      with partition
+namespace __unique {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class,class>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, int NOMINAL_4B_ITEMS_PER_THREAD>
+  struct items_per_thread
+  {
+    enum
+    {
+      value = mpl::min<
+          int,
+          NOMINAL_4B_ITEMS_PER_THREAD,
+          mpl::max<int,
+                   1,
+                   static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD * 4 /
+                    sizeof(T))>::value>::value
+    };
+  };
+
+  template<class T>
+  struct Tuning<sm52,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 11,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<64,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm52
+
+
+  template <class T>
+  struct Tuning<sm35, T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm35
+
+  template<class T>
+  struct Tuning<sm30,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm30
+
+  template <class ItemsIt,
+            class ItemsOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  struct UniqueAgent
+  {
+    typedef typename iterator_traits<ItemsIt>::value_type item_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, item_type>::type
+    {
+      typedef Tuning<Arch, item_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, ItemsIt>::type ItemsLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, ItemsLoadIt>::type BlockLoadItems;
+
+      typedef cub::BlockDiscontinuity<item_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityItems;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      typedef core::uninitialized_array<item_type, PtxPlan::ITEMS_PER_TILE>
+          shared_items_t;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage               scan;
+          typename TilePrefixCallback::TempStorage      prefix;
+          typename BlockDiscontinuityItems::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadItems::TempStorage  load_items;
+        shared_items_t shared_items;
+
+      };    // union TempStorage
+    };      // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::ItemsLoadIt             ItemsLoadIt;
+    typedef typename ptx_plan::BlockLoadItems          BlockLoadItems;
+    typedef typename ptx_plan::BlockDiscontinuityItems BlockDiscontinuityItems;
+    typedef typename ptx_plan::TilePrefixCallback      TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan               BlockScan;
+    typedef typename ptx_plan::shared_items_t          shared_items_t;
+    typedef typename ptx_plan::TempStorage             TempStorage;
+
+    enum
+    {
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      temp_storage;
+      ScanTileState &                    tile_state;
+      ItemsLoadIt                        items_in;
+      ItemsOutputIt                      items_out;
+      cub::InequalityWrapper<BinaryPred> predicate;
+      Size                               num_items;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      shared_items_t &get_shared()
+      {
+        return temp_storage.shared_items;
+      }
+
+      void THRUST_DEVICE_FUNCTION
+      scatter(item_type (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  /*num_tile_items*/,
+              int  num_tile_selections,
+              Size num_selections_prefix,
+              Size /*num_selections*/)
+      {
+        using core::sync_threadblock;
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int local_scatter_offset = selection_indices[ITEM] -
+                                     num_selections_prefix;
+          if (selection_flags[ITEM])
+          {
+            get_shared()[local_scatter_offset] = items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          items_out[num_selections_prefix + item] = get_shared()[item];
+        }
+
+        sync_threadblock();
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        using core::sync_threadblock;
+        using core::uninitialized_array;
+
+        item_type items_loc[ITEMS_PER_THREAD];
+        Size      selection_flags[ITEMS_PER_THREAD];
+        Size      selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE)
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_in + tile_base,
+                    items_loc,
+                    num_tile_items,
+                    *(items_in + tile_base));
+        }
+        else
+        {
+          BlockLoadItems(temp_storage.load_items)
+              .Load(items_in + tile_base, items_loc);
+        }
+
+
+        sync_threadblock();
+
+        if (IS_FIRST_TILE)
+        {
+          BlockDiscontinuityItems(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, items_loc, predicate);
+        }
+        else
+        {
+          item_type tile_predecessor = items_in[tile_base - 1];
+          BlockDiscontinuityItems(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, items_loc, predicate, tile_predecessor);
+        }
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set selection_flags for out-of-bounds items
+          if ((IS_LAST_TILE) &&
+              (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM >= num_tile_items))
+            selection_flags[ITEM] = 1;
+        }
+
+        sync_threadblock();
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       temp_storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        sync_threadblock();
+
+        scatter(items_loc,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        return num_selections;
+      }
+
+
+      template <bool IS_LAST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &    temp_storage_,
+           ScanTileState &  tile_state_,
+           ItemsLoadIt      items_in_,
+           ItemsOutputIt    items_out_,
+           BinaryPred       binary_pred_,
+           Size             num_items_,
+           int              num_tiles,
+           NumSelectedOutIt num_selected_out)
+          : temp_storage(temp_storage_),
+            tile_state(tile_state_),
+            items_in(items_in_),
+            items_out(items_out_),
+            predicate(binary_pred_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ItemsIt          items_in,
+                       ItemsOutputIt    items_out,
+                       BinaryPred       binary_pred,
+                       NumSelectedOutIt num_selected_out,
+                       Size             num_items,
+                       ScanTileState    tile_state,
+                       int              num_tiles,
+                       char *           shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           core::make_load_iterator(ptx_plan(), items_in),
+           items_out,
+           binary_pred,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  };    // struct UniqueAgent
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+
+  }; // struct InitAgent
+
+  template <class ItemsInputIt,
+            class ItemsOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  static cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *           d_temp_storage,
+            size_t &         temp_storage_bytes,
+            ItemsInputIt     items_in,
+            ItemsOutputIt    items_out,
+            BinaryPred       binary_pred,
+            NumSelectedOutIt num_selected_out,
+            Size             num_items,
+            cudaStream_t     stream)
+  {
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        UniqueAgent<ItemsInputIt,
+                    ItemsOutputIt,
+                    BinaryPred,
+                    Size,
+                    NumSelectedOutIt> >
+        unique_agent;
+
+    typedef typename unique_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type   init_plan   = init_agent::get_plan();
+    typename get_plan<unique_agent>::type unique_plan = unique_agent::get_plan(stream);
+
+
+    int tile_size = unique_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(unique_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    size_t      allocation_sizes[2] = {0, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    //
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status =  tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    num_tiles = max<size_t>(1,num_tiles);
+    init_agent ia(init_plan, num_tiles, stream, "unique_by_key::init_agent");
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    if (num_items == 0) { return status; }
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    unique_agent ua(unique_plan, num_items, stream, vshmem_ptr, "unique_by_key::unique_agent");
+    ua.launch(items_in,
+              items_out,
+              binary_pred,
+              num_selected_out,
+              num_items,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename ItemsInputIt,
+            typename ItemsOutputIt,
+            typename BinaryPred>
+  THRUST_RUNTIME_FUNCTION
+  ItemsOutputIt unique(execution_policy<Derived>& policy,
+                       ItemsInputIt               items_first,
+                       ItemsInputIt               items_last,
+                       ItemsOutputIt              items_result,
+                       BinaryPred                 binary_pred)
+  {
+    //  typedef typename iterator_traits<ItemsInputIt>::difference_type size_type;
+    typedef int size_type;
+
+    size_type    num_items          = static_cast<size_type>(thrust::distance(items_first, items_last));
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = doit_step(NULL,
+                       temp_storage_bytes,
+                       items_first,
+                       items_result,
+                       binary_pred,
+                       reinterpret_cast<size_type*>(NULL),
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "unique: failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique: failed on 1st step");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique: failed on 2nd step");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = doit_step(allocations[1],
+                       temp_storage_bytes,
+                       items_first,
+                       items_result,
+                       binary_pred,
+                       d_num_selected_out,
+                       num_items,
+                       stream);
+    cuda_cub::throw_on_error(status, "unique: failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "unique: failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return items_result + num_selected;
+  }
+}    // namespace __unique
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class InputIt,
+          class OutputIt,
+          class BinaryPred>
+OutputIt __host__ __device__
+unique_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result,
+            BinaryPred                 binary_pred)
+{
+  THRUST_CDP_DISPATCH(
+    (result = __unique::unique(policy, first, last, result, binary_pred);),
+    (result = thrust::unique_copy(cvt_to_seq(derived_cast(policy)),
+                                  first,
+                                  last,
+                                  result,
+                                  binary_pred);));
+  return result;
+}
+
+template <class Derived,
+          class InputIt,
+          class OutputIt>
+OutputIt __host__ __device__
+unique_copy(execution_policy<Derived> &policy,
+            InputIt                    first,
+            InputIt                    last,
+            OutputIt                   result)
+{
+  typedef typename iterator_traits<InputIt>::value_type input_type;
+  return cuda_cub::unique_copy(policy, first, last, result, equal_to<input_type>());
+}
+
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ForwardIt,
+          class BinaryPred>
+ForwardIt __host__ __device__
+unique(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last,
+       BinaryPred                 binary_pred)
+{
+  ForwardIt ret = first;
+  THRUST_CDP_DISPATCH(
+    (ret = cuda_cub::unique_copy(policy, first, last, first, binary_pred);),
+    (ret = thrust::unique(cvt_to_seq(derived_cast(policy)),
+                          first,
+                          last,
+                          binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class ForwardIt>
+ForwardIt __host__ __device__
+unique(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type input_type;
+  return cuda_cub::unique(policy, first, last, equal_to<input_type>());
+}
+
+
+template <typename BinaryPred>
+struct zip_adj_not_predicate {
+  template <typename TupleType>
+  bool __host__ __device__ operator()(TupleType&& tuple) {
+      return !binary_pred(thrust::get<0>(tuple), thrust::get<1>(tuple));
+  }
+  
+  BinaryPred binary_pred;
+};
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class ForwardIt,
+          class BinaryPred>
+typename thrust::iterator_traits<ForwardIt>::difference_type
+__host__ __device__
+unique_count(execution_policy<Derived> &policy,
+       ForwardIt                  first,
+       ForwardIt                  last,
+       BinaryPred                 binary_pred)
+{
+  if (first == last) {
+    return 0;
+  }
+  auto size = thrust::distance(first, last);
+  auto it = thrust::make_zip_iterator(thrust::make_tuple(first, thrust::next(first)));
+  return 1 + thrust::count_if(policy, it, thrust::next(it, size - 1), zip_adj_not_predicate<BinaryPred>{binary_pred});
+}
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+//
+#include <thrust/memory.h>
+#include <thrust/unique.h>
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique_by_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique_by_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5ce8e786f8d090c6b0b0f2e1053156f59287e34
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/unique_by_key.h
@@ -0,0 +1,919 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/cstdint.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/detail/mpl/math.h>
+#include <thrust/distance.h>
+#include <thrust/functional.h>
+#include <thrust/pair.h>
+#include <thrust/system/cuda/config.h>
+#include <thrust/system/cuda/detail/cdp_dispatch.h>
+#include <thrust/system/cuda/detail/core/agent_launcher.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/cuda/detail/par_to_seq.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <cub/device/device_select.cuh>
+#include <cub/util_math.cuh>
+
+THRUST_NAMESPACE_BEGIN
+
+template <typename DerivedPolicy,
+          typename ForwardIterator1,
+          typename ForwardIterator2>
+__host__ __device__ thrust::pair<ForwardIterator1, ForwardIterator2>
+unique_by_key(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    ForwardIterator1                                            keys_first,
+    ForwardIterator1                                            keys_last,
+    ForwardIterator2                                            values_first);
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2>
+__host__ __device__ thrust::pair<OutputIterator1, OutputIterator2>
+unique_by_key_copy(
+    const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+    InputIterator1                                              keys_first,
+    InputIterator1                                              keys_last,
+    InputIterator2                                              values_first,
+    OutputIterator1                                             keys_result,
+    OutputIterator2                                             values_result);
+
+
+namespace cuda_cub {
+
+// XXX  it should be possible to unify unique & unique_by_key into a single
+//      agent with various specializations, similar to what is done
+//      with partition
+namespace __unique_by_key {
+
+  template <int                     _BLOCK_THREADS,
+            int                     _ITEMS_PER_THREAD = 1,
+            cub::BlockLoadAlgorithm _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
+            cub::CacheLoadModifier  _LOAD_MODIFIER    = cub::LOAD_LDG,
+            cub::BlockScanAlgorithm _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
+  struct PtxPolicy
+  {
+    enum
+    {
+      BLOCK_THREADS    = _BLOCK_THREADS,
+      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = _BLOCK_THREADS * _ITEMS_PER_THREAD,
+    };
+    static const cub::BlockLoadAlgorithm LOAD_ALGORITHM = _LOAD_ALGORITHM;
+    static const cub::CacheLoadModifier  LOAD_MODIFIER  = _LOAD_MODIFIER;
+    static const cub::BlockScanAlgorithm SCAN_ALGORITHM = _SCAN_ALGORITHM;
+  };    // struct PtxPolicy
+
+  template<class,class>
+  struct Tuning;
+
+  namespace mpl = thrust::detail::mpl::math;
+
+  template<class T, size_t NOMINAL_4B_ITEMS_PER_THREAD>
+  struct items_per_thread
+  {
+    enum
+    {
+      value = mpl::min<
+          int,
+          static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD),
+          mpl::max<int,
+                   1,
+                   static_cast<int>(NOMINAL_4B_ITEMS_PER_THREAD * 4 /
+                   sizeof(T))>::value>::value
+    };
+  };
+
+
+  template<class T>
+  struct Tuning<sm52,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 11,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<64,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm52
+
+  template<class T>
+  struct Tuning<sm35,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 9,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_LDG,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm35
+
+  template<class T>
+  struct Tuning<sm30,T>
+  {
+    const static int INPUT_SIZE = sizeof(T);
+    enum
+    {
+      NOMINAL_4B_ITEMS_PER_THREAD = 7,
+      //
+      ITEMS_PER_THREAD = items_per_thread<T,
+                                          NOMINAL_4B_ITEMS_PER_THREAD>::value
+    };
+
+    typedef PtxPolicy<128,
+                      ITEMS_PER_THREAD,
+                      cub::BLOCK_LOAD_WARP_TRANSPOSE,
+                      cub::LOAD_DEFAULT,
+                      cub::BLOCK_SCAN_WARP_SCANS>
+        type;
+  };    // Tuning for sm30
+
+  template <class KeyInputIt,
+            class ValInputIt,
+            class KeyOutputIt,
+            class ValOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  struct UniqueByKeyAgent
+  {
+    typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+    typedef typename iterator_traits<ValInputIt>::value_type value_type;
+
+    typedef cub::ScanTileState<Size> ScanTileState;
+
+    template <class Arch>
+    struct PtxPlan : Tuning<Arch, key_type>::type
+    {
+      typedef Tuning<Arch, key_type> tuning;
+
+      typedef typename core::LoadIterator<PtxPlan, KeyInputIt>::type KeyLoadIt;
+      typedef typename core::LoadIterator<PtxPlan, ValInputIt>::type ValLoadIt;
+
+      typedef typename core::BlockLoad<PtxPlan, KeyLoadIt>::type BlockLoadKeys;
+      typedef typename core::BlockLoad<PtxPlan, ValLoadIt>::type BlockLoadValues;
+
+      typedef cub::BlockDiscontinuity<key_type,
+                                      PtxPlan::BLOCK_THREADS,
+                                      1,
+                                      1,
+                                      Arch::ver>
+          BlockDiscontinuityKeys;
+
+      typedef cub::TilePrefixCallbackOp<Size,
+                                        cub::Sum,
+                                        ScanTileState,
+                                        Arch::ver>
+          TilePrefixCallback;
+      typedef cub::BlockScan<Size,
+                             PtxPlan::BLOCK_THREADS,
+                             PtxPlan::SCAN_ALGORITHM,
+                             1,
+                             1,
+                             Arch::ver>
+          BlockScan;
+
+      typedef core::uninitialized_array<key_type, PtxPlan::ITEMS_PER_TILE>
+          shared_keys_t;
+      typedef core::uninitialized_array<value_type, PtxPlan::ITEMS_PER_TILE>
+          shared_values_t;
+
+      union TempStorage
+      {
+        struct ScanStorage
+        {
+          typename BlockScan::TempStorage              scan;
+          typename TilePrefixCallback::TempStorage     prefix;
+          typename BlockDiscontinuityKeys::TempStorage discontinuity;
+        } scan_storage;
+
+        typename BlockLoadKeys::TempStorage   load_keys;
+        typename BlockLoadValues::TempStorage load_values;
+
+        shared_keys_t   shared_keys;
+        shared_values_t shared_values;
+      };    // union TempStorage
+    };    // struct PtxPlan
+
+    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
+
+    typedef typename ptx_plan::KeyLoadIt              KeyLoadIt;
+    typedef typename ptx_plan::ValLoadIt              ValLoadIt;
+    typedef typename ptx_plan::BlockLoadKeys          BlockLoadKeys;
+    typedef typename ptx_plan::BlockLoadValues        BlockLoadValues;
+    typedef typename ptx_plan::BlockDiscontinuityKeys BlockDiscontinuityKeys;
+    typedef typename ptx_plan::TilePrefixCallback     TilePrefixCallback;
+    typedef typename ptx_plan::BlockScan              BlockScan;
+    typedef typename ptx_plan::TempStorage            TempStorage;
+    typedef typename ptx_plan::shared_keys_t          shared_keys_t;
+    typedef typename ptx_plan::shared_values_t        shared_values_t;
+
+    enum
+    {
+      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
+      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
+      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE
+    };
+
+    struct impl
+    {
+      //---------------------------------------------------------------------
+      // Per-thread fields
+      //---------------------------------------------------------------------
+
+      TempStorage &                      temp_storage;
+      ScanTileState &                    tile_state;
+      KeyLoadIt                          keys_in;
+      ValLoadIt                          values_in;
+      KeyOutputIt                        keys_out;
+      ValOutputIt                        values_out;
+      cub::InequalityWrapper<BinaryPred> predicate;
+      Size                               num_items;
+
+      //---------------------------------------------------------------------
+      // Utility functions
+      //---------------------------------------------------------------------
+
+      struct key_tag {};
+      struct value_tag {};
+
+      THRUST_DEVICE_FUNCTION
+      shared_keys_t &get_shared(key_tag)
+      {
+        return temp_storage.shared_keys;
+      }
+      THRUST_DEVICE_FUNCTION
+      shared_values_t &get_shared(value_tag)
+      {
+        return temp_storage.shared_values;
+      }
+
+
+      template <class Tag,
+                class OutputIt,
+                class T>
+      void THRUST_DEVICE_FUNCTION
+      scatter(Tag      tag,
+              OutputIt items_out,
+              T (&items)[ITEMS_PER_THREAD],
+              Size (&selection_flags)[ITEMS_PER_THREAD],
+              Size (&selection_indices)[ITEMS_PER_THREAD],
+              int  /*num_tile_items*/,
+              int  num_tile_selections,
+              Size num_selections_prefix,
+              Size /*num_selections*/)
+      {
+        using core::sync_threadblock;
+
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          int local_scatter_offset = selection_indices[ITEM] -
+                                     num_selections_prefix;
+          if (selection_flags[ITEM])
+          {
+            get_shared(tag)[local_scatter_offset] = items[ITEM];
+          }
+        }
+
+        sync_threadblock();
+
+        for (int item = threadIdx.x;
+             item < num_tile_selections;
+             item += BLOCK_THREADS)
+        {
+          items_out[num_selections_prefix + item] = get_shared(tag)[item];
+        }
+
+        sync_threadblock();
+      }
+
+      //---------------------------------------------------------------------
+      // Tile processing
+      //---------------------------------------------------------------------
+
+      template <bool IS_LAST_TILE, bool IS_FIRST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile_impl(int  num_tile_items,
+                        int  tile_idx,
+                        Size tile_base)
+      {
+        using core::sync_threadblock;
+
+        key_type keys[ITEMS_PER_THREAD];
+        Size     selection_flags[ITEMS_PER_THREAD];
+        Size     selection_idx[ITEMS_PER_THREAD];
+
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadKeys(temp_storage.load_keys)
+              .Load(keys_in + tile_base,
+                    keys,
+                    num_tile_items,
+                    *(keys_in + tile_base));
+        }
+        else
+        {
+          BlockLoadKeys(temp_storage.load_keys).Load(keys_in + tile_base, keys);
+        }
+
+
+        sync_threadblock();
+
+        value_type values[ITEMS_PER_THREAD];
+        if (IS_LAST_TILE)
+        {
+          // Fill last elements with the first element
+          // because collectives are not suffix guarded
+          BlockLoadValues(temp_storage.load_values)
+              .Load(values_in + tile_base,
+                    values,
+                    num_tile_items,
+                    *(values_in + tile_base));
+        }
+        else
+        {
+          BlockLoadValues(temp_storage.load_values)
+              .Load(values_in + tile_base, values);
+        }
+
+        sync_threadblock();
+
+        if (IS_FIRST_TILE)
+        {
+          BlockDiscontinuityKeys(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, keys, predicate);
+        }
+        else
+        {
+          key_type tile_predecessor = keys_in[tile_base - 1];
+          BlockDiscontinuityKeys(temp_storage.scan_storage.discontinuity)
+              .FlagHeads(selection_flags, keys, predicate, tile_predecessor);
+        }
+#pragma unroll
+        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
+        {
+          // Set selection_flags for out-of-bounds items
+          if ((IS_LAST_TILE) && (Size(threadIdx.x * ITEMS_PER_THREAD) + ITEM >= num_tile_items))
+            selection_flags[ITEM] = 1;
+        }
+
+        sync_threadblock();
+
+
+        Size num_tile_selections   = 0;
+        Size num_selections        = 0;
+        Size num_selections_prefix = 0;
+        if (IS_FIRST_TILE)
+        {
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            num_tile_selections);
+
+          if (threadIdx.x == 0)
+          {
+            // Update tile status if this is not the last tile
+            if (!IS_LAST_TILE)
+              tile_state.SetInclusive(0, num_tile_selections);
+          }
+
+          // Do not count any out-of-bounds selections
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+          }
+          num_selections = num_tile_selections;
+        }
+        else
+        {
+          TilePrefixCallback prefix_cb(tile_state,
+                                       temp_storage.scan_storage.prefix,
+                                       cub::Sum(),
+                                       tile_idx);
+          BlockScan(temp_storage.scan_storage.scan)
+              .ExclusiveSum(selection_flags,
+                            selection_idx,
+                            prefix_cb);
+
+          num_selections        = prefix_cb.GetInclusivePrefix();
+          num_tile_selections   = prefix_cb.GetBlockAggregate();
+          num_selections_prefix = prefix_cb.GetExclusivePrefix();
+
+          if (IS_LAST_TILE)
+          {
+            int num_discount = ITEMS_PER_TILE - num_tile_items;
+            num_tile_selections -= num_discount;
+            num_selections -= num_discount;
+          }
+        }
+
+        sync_threadblock();
+
+        scatter(key_tag(),
+                keys_out,
+                keys,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        sync_threadblock();
+
+        scatter(value_tag(),
+                values_out,
+                values,
+                selection_flags,
+                selection_idx,
+                num_tile_items,
+                num_tile_selections,
+                num_selections_prefix,
+                num_selections);
+
+        return num_selections;
+      }
+
+
+      template <bool IS_LAST_TILE>
+      Size THRUST_DEVICE_FUNCTION
+      consume_tile(int  num_tile_items,
+                   int  tile_idx,
+                   Size tile_base)
+      {
+        if (tile_idx == 0)
+        {
+          return consume_tile_impl<IS_LAST_TILE, true>(num_tile_items,
+                                                       tile_idx,
+                                                       tile_base);
+        }
+        else
+        {
+          return consume_tile_impl<IS_LAST_TILE, false>(num_tile_items,
+                                                        tile_idx,
+                                                        tile_base);
+        }
+      }
+
+      //---------------------------------------------------------------------
+      // Constructor
+      //---------------------------------------------------------------------
+
+      THRUST_DEVICE_FUNCTION
+      impl(TempStorage &    temp_storage_,
+           ScanTileState &  tile_state_,
+           KeyLoadIt        keys_in_,
+           ValLoadIt        values_in_,
+           KeyOutputIt      keys_out_,
+           ValOutputIt      values_out_,
+           BinaryPred       binary_pred_,
+           Size             num_items_,
+           int              num_tiles,
+           NumSelectedOutIt num_selected_out)
+          // filed ctors
+          : temp_storage(temp_storage_),
+            tile_state(tile_state_),
+            keys_in(keys_in_),
+            values_in(values_in_),
+            keys_out(keys_out_),
+            values_out(values_out_),
+            predicate(binary_pred_),
+            num_items(num_items_)
+      {
+        int  tile_idx  = blockIdx.x;
+        Size tile_base = tile_idx * ITEMS_PER_TILE;
+
+        if (tile_idx < num_tiles - 1)
+        {
+          consume_tile<false>(ITEMS_PER_TILE,
+                              tile_idx,
+                              tile_base);
+        }
+        else
+        {
+          int  num_remaining  = static_cast<int>(num_items - tile_base);
+          Size num_selections = consume_tile<true>(num_remaining,
+                                                   tile_idx,
+                                                   tile_base);
+          if (threadIdx.x == 0)
+          {
+            *num_selected_out = num_selections;
+          }
+        }
+      }
+    };    // struct impl
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(KeyInputIt       keys_in,
+                       ValInputIt       values_in,
+                       KeyOutputIt      keys_out,
+                       ValOutputIt      values_out,
+                       BinaryPred       binary_pred,
+                       NumSelectedOutIt num_selected_out,
+                       Size             num_items,
+                       ScanTileState    tile_state,
+                       int              num_tiles,
+                       char *           shmem)
+    {
+      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
+
+      impl(storage,
+           tile_state,
+           core::make_load_iterator(ptx_plan(), keys_in),
+           core::make_load_iterator(ptx_plan(), values_in),
+           keys_out,
+           values_out,
+           binary_pred,
+           num_items,
+           num_tiles,
+           num_selected_out);
+    }
+  }; // struct UniqueByKeyAgent
+
+
+  template <class ScanTileState,
+            class NumSelectedIt,
+            class Size>
+  struct InitAgent
+  {
+    template <class Arch>
+    struct PtxPlan : PtxPolicy<128> {};
+
+    typedef core::specialize_plan<PtxPlan> ptx_plan;
+
+    //---------------------------------------------------------------------
+    // Agent entry point
+    //---------------------------------------------------------------------
+
+    THRUST_AGENT_ENTRY(ScanTileState tile_state,
+                       Size          num_tiles,
+                       NumSelectedIt num_selected_out,
+                       char * /*shmem*/)
+    {
+      tile_state.InitializeStatus(num_tiles);
+      if (blockIdx.x == 0 && threadIdx.x == 0)
+        *num_selected_out = 0;
+    }
+
+  }; // struct InitAgent
+
+
+  template <class KeyInputIt,
+            class ValInputIt,
+            class KeyOutputIt,
+            class ValOutputIt,
+            class BinaryPred,
+            class Size,
+            class NumSelectedOutIt>
+  static cudaError_t THRUST_RUNTIME_FUNCTION
+  doit_step(void *           d_temp_storage,
+            size_t &         temp_storage_bytes,
+            KeyInputIt       keys_in,
+            ValInputIt       values_in,
+            KeyOutputIt      keys_out,
+            ValOutputIt      values_out,
+            BinaryPred       binary_pred,
+            NumSelectedOutIt num_selected_out,
+            Size             num_items,
+            cudaStream_t     stream)
+  {
+    using core::AgentLauncher;
+    using core::AgentPlan;
+    using core::get_agent_plan;
+
+    typedef AgentLauncher<
+        UniqueByKeyAgent<KeyInputIt,
+                         ValInputIt,
+                         KeyOutputIt,
+                         ValOutputIt,
+                         BinaryPred,
+                         Size,
+                         NumSelectedOutIt> >
+        unique_agent;
+
+    typedef typename unique_agent::ScanTileState ScanTileState;
+
+    typedef AgentLauncher<
+        InitAgent<ScanTileState, NumSelectedOutIt, Size> >
+        init_agent;
+
+    using core::get_plan;
+    typename get_plan<init_agent>::type   init_plan   = init_agent::get_plan();
+    typename get_plan<unique_agent>::type unique_plan = unique_agent::get_plan(stream);
+
+
+    int tile_size = unique_plan.items_per_tile;
+    size_t num_tiles = cub::DivideAndRoundUp(num_items, tile_size);
+
+    size_t vshmem_size = core::vshmem_size(unique_plan.shared_memory_size,
+                                           num_tiles);
+
+    cudaError_t status = cudaSuccess;
+    size_t      allocation_sizes[2] = {0, vshmem_size};
+    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    void *allocations[2] = {NULL, NULL};
+    //
+    status = cub::AliasTemporaries(d_temp_storage,
+                                   temp_storage_bytes,
+                                   allocations,
+                                   allocation_sizes);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    if (d_temp_storage == NULL)
+    {
+      return status;
+    }
+
+    ScanTileState tile_status;
+    status =  tile_status.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
+    CUDA_CUB_RET_IF_FAIL(status);
+
+    num_tiles = max<size_t>(1,num_tiles);
+    init_agent ia(init_plan, num_tiles, stream, "unique_by_key::init_agent");
+    ia.launch(tile_status, num_tiles, num_selected_out);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+
+    if (num_items == 0) { return status; }
+
+    char *vshmem_ptr = vshmem_size > 0 ? (char *)allocations[1] : NULL;
+
+    unique_agent ua(unique_plan, num_items, stream, vshmem_ptr, "unique_by_key::unique_agent");
+    ua.launch(keys_in,
+              values_in,
+              keys_out,
+              values_out,
+              binary_pred,
+              num_selected_out,
+              num_items,
+              tile_status,
+              num_tiles);
+    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
+    return status;
+  }
+
+  template <typename Derived,
+            typename KeyInputIt,
+            typename ValInputIt,
+            typename KeyOutputIt,
+            typename ValOutputIt,
+            typename BinaryPred>
+  THRUST_RUNTIME_FUNCTION
+  pair<KeyOutputIt, ValOutputIt>
+  unique_by_key(execution_policy<Derived>& policy,
+                KeyInputIt                 keys_first,
+                KeyInputIt                 keys_last,
+                ValInputIt                 values_first,
+                KeyOutputIt                keys_result,
+                ValOutputIt                values_result,
+                BinaryPred                 binary_pred)
+  {
+
+    typedef int size_type;
+
+    size_type num_items
+      = static_cast<size_type>(thrust::distance(keys_first, keys_last));
+
+    size_t       temp_storage_bytes = 0;
+    cudaStream_t stream             = cuda_cub::stream(policy);
+
+    cudaError_t status;
+    status = __unique_by_key::doit_step(NULL,
+                                        temp_storage_bytes,
+                                        keys_first,
+                                        values_first,
+                                        keys_result,
+                                        values_result,
+                                        binary_pred,
+                                        reinterpret_cast<size_type*>(NULL),
+                                        num_items,
+                                        stream);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed on 1st step");
+
+    size_t allocation_sizes[2] = {sizeof(size_type), temp_storage_bytes};
+    void * allocations[2]      = {NULL, NULL};
+
+    size_t storage_size = 0;
+    status = core::alias_storage(NULL,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique_by_key failed on 1st alias_storage");
+
+    // Allocate temporary storage.
+    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
+      tmp(policy, storage_size);
+    void *ptr = static_cast<void*>(tmp.data().get());
+
+    status = core::alias_storage(ptr,
+                                 storage_size,
+                                 allocations,
+                                 allocation_sizes);
+    cuda_cub::throw_on_error(status, "unique_by_key failed on 2nd alias_storage");
+
+    size_type* d_num_selected_out
+      = thrust::detail::aligned_reinterpret_cast<size_type*>(allocations[0]);
+
+    status = __unique_by_key::doit_step(allocations[1],
+                                        temp_storage_bytes,
+                                        keys_first,
+                                        values_first,
+                                        keys_result,
+                                        values_result,
+                                        binary_pred,
+                                        d_num_selected_out,
+                                        num_items,
+                                        stream);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed on 2nd step");
+
+    status = cuda_cub::synchronize(policy);
+    cuda_cub::throw_on_error(status, "unique_by_key: failed to synchronize");
+
+    size_type num_selected = get_value(policy, d_num_selected_out);
+
+    return thrust::make_pair(
+      keys_result + num_selected,
+      values_result + num_selected
+    );
+  }
+
+} // namespace __unique_by_key
+
+
+//-------------------------
+// Thrust API entry points
+//-------------------------
+
+
+__thrust_exec_check_disable__
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt,
+          class BinaryPred>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+unique_by_key_copy(execution_policy<Derived> &policy,
+                   KeyInputIt                 keys_first,
+                   KeyInputIt                 keys_last,
+                   ValInputIt                 values_first,
+                   KeyOutputIt                keys_result,
+                   ValOutputIt                values_result,
+                   BinaryPred                 binary_pred)
+{
+  auto ret = thrust::make_pair(keys_result, values_result);
+  THRUST_CDP_DISPATCH(
+    (ret = __unique_by_key::unique_by_key(policy,
+                                          keys_first,
+                                          keys_last,
+                                          values_first,
+                                          keys_result,
+                                          values_result,
+                                          binary_pred);),
+    (ret = thrust::unique_by_key_copy(cvt_to_seq(derived_cast(policy)),
+                                      keys_first,
+                                      keys_last,
+                                      values_first,
+                                      keys_result,
+                                      values_result,
+                                      binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class KeyOutputIt,
+          class ValOutputIt>
+pair<KeyOutputIt, ValOutputIt> __host__ __device__
+unique_by_key_copy(execution_policy<Derived> &policy,
+                   KeyInputIt                 keys_first,
+                   KeyInputIt                 keys_last,
+                   ValInputIt                 values_first,
+                   KeyOutputIt                keys_result,
+                   ValOutputIt                values_result)
+{
+  typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+  return cuda_cub::unique_by_key_copy(policy,
+                                   keys_first,
+                                   keys_last,
+                                   values_first,
+                                   keys_result,
+                                   values_result,
+                                   equal_to<key_type>());
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt,
+          class BinaryPred>
+pair<KeyInputIt, ValInputIt> __host__ __device__
+unique_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first,
+              BinaryPred                 binary_pred)
+{
+  auto ret = thrust::make_pair(keys_first, values_first);
+  THRUST_CDP_DISPATCH(
+    (ret = cuda_cub::unique_by_key_copy(policy,
+                                         keys_first,
+                                         keys_last,
+                                         values_first,
+                                         keys_first,
+                                         values_first,
+                                         binary_pred);),
+    (ret = thrust::unique_by_key(cvt_to_seq(derived_cast(policy)),
+                                  keys_first,
+                                  keys_last,
+                                  values_first,
+                                  binary_pred);));
+  return ret;
+}
+
+template <class Derived,
+          class KeyInputIt,
+          class ValInputIt>
+pair<KeyInputIt, ValInputIt> __host__ __device__
+unique_by_key(execution_policy<Derived> &policy,
+              KeyInputIt                 keys_first,
+              KeyInputIt                 keys_last,
+              ValInputIt                 values_first)
+{
+  typedef typename iterator_traits<KeyInputIt>::value_type key_type;
+  return cuda_cub::unique_by_key(policy,
+                              keys_first,
+                              keys_last,
+                              values_first,
+                              equal_to<key_type>());
+}
+
+
+
+}    // namespace cuda_cub
+THRUST_NAMESPACE_END
+
+#include <thrust/memory.h>
+#include <thrust/unique.h>
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d9e3681d8c276c3f9aafca60f1ce0db5abe28ff
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/detail/util.h
@@ -0,0 +1,641 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights meserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <cstdio>
+#include <exception>
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system_error.h>
+#include <thrust/system/cuda/error.h>
+
+#include <cub/detail/device_synchronize.cuh>
+#include <cub/util_arch.cuh>
+#include <cub/util_device.cuh>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub {
+
+inline __host__ __device__
+cudaStream_t
+default_stream()
+{
+#ifdef CUDA_API_PER_THREAD_DEFAULT_STREAM
+  return cudaStreamPerThread;
+#else
+  return cudaStreamLegacy;
+#endif
+}
+
+// Fallback implementation of the customization point.
+template <class Derived>
+__host__ __device__
+cudaStream_t
+get_stream(execution_policy<Derived> &)
+{
+  return default_stream();
+}
+
+// Entry point/interface.
+template <class Derived>
+__host__ __device__ cudaStream_t
+stream(execution_policy<Derived> &policy)
+{
+  return get_stream(derived_cast(policy));
+}
+
+
+// Fallback implementation of the customization point.
+template <class Derived>
+__host__ __device__
+bool
+must_perform_optional_stream_synchronization(execution_policy<Derived> &)
+{
+  return true;
+}
+
+// Entry point/interface.
+template <class Derived>
+__host__ __device__ bool
+must_perform_optional_synchronization(execution_policy<Derived> &policy)
+{
+  return must_perform_optional_stream_synchronization(derived_cast(policy));
+}
+
+
+// Fallback implementation of the customization point.
+__thrust_exec_check_disable__
+template <class Derived>
+__host__ __device__
+cudaError_t
+synchronize_stream(execution_policy<Derived> &policy)
+{
+  return cub::SyncStream(stream(policy));
+}
+
+// Entry point/interface.
+template <class Policy>
+__host__ __device__
+cudaError_t
+synchronize(Policy &policy)
+{
+  return synchronize_stream(derived_cast(policy));
+}
+
+// Fallback implementation of the customization point.
+__thrust_exec_check_disable__
+template <class Derived>
+__host__ __device__
+cudaError_t
+synchronize_stream_optional(execution_policy<Derived> &policy)
+{
+  cudaError_t result;
+
+  if (must_perform_optional_synchronization(policy))
+  {
+    result = synchronize_stream(policy);
+  }
+  else
+  {
+    result = cudaSuccess;
+  }
+
+  return result;
+}
+
+// Entry point/interface.
+template <class Policy>
+__host__ __device__
+cudaError_t
+synchronize_optional(Policy &policy)
+{
+  return synchronize_stream_optional(derived_cast(policy));
+}
+
+template <class Type>
+THRUST_HOST_FUNCTION cudaError_t
+trivial_copy_from_device(Type *       dst,
+                         Type const * src,
+                         size_t       count,
+                         cudaStream_t stream)
+{
+  cudaError status = cudaSuccess;
+  if (count == 0) return status;
+
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyDeviceToHost,
+                             stream);
+  cudaStreamSynchronize(stream);
+  return status;
+}
+
+template <class Type>
+THRUST_HOST_FUNCTION cudaError_t
+trivial_copy_to_device(Type *       dst,
+                       Type const * src,
+                       size_t       count,
+                       cudaStream_t stream)
+{
+  cudaError status = cudaSuccess;
+  if (count == 0) return status;
+
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyHostToDevice,
+                             stream);
+  cudaStreamSynchronize(stream);
+  return status;
+}
+
+template <class Policy, class Type>
+__host__ __device__ cudaError_t
+trivial_copy_device_to_device(Policy &    policy,
+                              Type *      dst,
+                              Type const *src,
+                              size_t      count)
+{
+  cudaError_t  status = cudaSuccess;
+  if (count == 0) return status;
+
+  cudaStream_t stream = cuda_cub::stream(policy);
+  //
+  status = ::cudaMemcpyAsync(dst,
+                             src,
+                             sizeof(Type) * count,
+                             cudaMemcpyDeviceToDevice,
+                             stream);
+  cuda_cub::synchronize(policy);
+  return status;
+}
+
+inline void __host__ __device__
+terminate()
+{
+  NV_IF_TARGET(NV_IS_HOST, (std::terminate();), (asm("trap;");));
+}
+
+__host__  __device__
+inline void throw_on_error(cudaError_t status)
+{
+  // Clear the global CUDA error state which may have been set by the last
+  // call. Otherwise, errors may "leak" to unrelated kernel launches.
+#ifdef THRUST_RDC_ENABLED
+  cudaGetLastError();
+#else
+  NV_IF_TARGET(NV_IS_HOST, (cudaGetLastError();));
+#endif
+
+  if (cudaSuccess != status)
+  {
+
+    // Can't use #if inside NV_IF_TARGET, use a temp macro to hoist the device
+    // instructions out of the target logic.
+#ifdef THRUST_RDC_ENABLED
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %s: %s\n", \
+         cudaGetErrorName(status), \
+         cudaGetErrorString(status))
+
+#else
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %d\n", \
+         static_cast<int>(status))
+
+#endif
+
+    NV_IF_TARGET(NV_IS_HOST, (
+      throw thrust::system_error(status, thrust::cuda_category());
+    ), (
+      THRUST_TEMP_DEVICE_CODE;
+      cuda_cub::terminate();
+    ));
+
+#undef THRUST_TEMP_DEVICE_CODE
+
+  }
+}
+
+__host__ __device__
+inline void throw_on_error(cudaError_t status, char const *msg)
+{
+  // Clear the global CUDA error state which may have been set by the last
+  // call. Otherwise, errors may "leak" to unrelated kernel launches.
+#ifdef THRUST_RDC_ENABLED
+  cudaGetLastError();
+#else
+  NV_IF_TARGET(NV_IS_HOST, (cudaGetLastError();));
+#endif
+
+  if (cudaSuccess != status)
+  {
+    // Can't use #if inside NV_IF_TARGET, use a temp macro to hoist the device
+    // instructions out of the target logic.
+#ifdef THRUST_RDC_ENABLED
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %s: %s: %s\n", \
+         cudaGetErrorName(status), \
+         cudaGetErrorString(status),\
+         msg)
+
+#else
+
+#define THRUST_TEMP_DEVICE_CODE \
+  printf("Thrust CUDA backend error: %d: %s\n", \
+         static_cast<int>(status),              \
+         msg)
+
+#endif
+
+    NV_IF_TARGET(NV_IS_HOST, (
+      throw thrust::system_error(status, thrust::cuda_category(), msg);
+    ), (
+      THRUST_TEMP_DEVICE_CODE;
+      cuda_cub::terminate();
+    ));
+
+#undef THRUST_TEMP_DEVICE_CODE
+
+  }
+}
+
+// FIXME: Move the iterators elsewhere.
+
+template <class ValueType,
+          class InputIt,
+          class UnaryOp>
+struct transform_input_iterator_t
+{
+  typedef transform_input_iterator_t                         self_t;
+  typedef typename iterator_traits<InputIt>::difference_type difference_type;
+  typedef ValueType                                          value_type;
+  typedef void                                               pointer;
+  typedef value_type                                         reference;
+  typedef std::random_access_iterator_tag                    iterator_category;
+
+  InputIt         input;
+  mutable UnaryOp op;
+
+  __host__ __device__ __forceinline__
+  transform_input_iterator_t(InputIt input, UnaryOp op)
+      : input(input), op(op) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  transform_input_iterator_t(const self_t &) = default;
+#endif
+
+  // UnaryOp might not be copy assignable, such as when it is a lambda.  Define
+  // an explicit copy assignment operator that doesn't try to assign it.
+  __host__ __device__ 
+  self_t& operator=(const self_t& o)
+  {
+    input = o.input;
+    return *this;
+  }
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++input;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++input;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    typename thrust::iterator_value<InputIt>::type x = *input;
+    return op(x);
+  }
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    typename thrust::iterator_value<InputIt>::type x = *input;
+    return op(x);
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(input + n, op);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    input += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(input - n, op);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    input -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return input - other.input;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return op(input[n]);
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (input == rhs.input);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (input != rhs.input);
+  }
+};    // struct transform_input_iterarot_t
+
+template <class ValueType,
+          class InputIt1,
+          class InputIt2,
+          class BinaryOp>
+struct transform_pair_of_input_iterators_t
+{
+  typedef transform_pair_of_input_iterators_t                 self_t;
+  typedef typename iterator_traits<InputIt1>::difference_type difference_type;
+  typedef ValueType                                           value_type;
+  typedef void                                                pointer;
+  typedef value_type                                          reference;
+  typedef std::random_access_iterator_tag                     iterator_category;
+
+  InputIt1         input1;
+  InputIt2         input2;
+  mutable BinaryOp op;
+
+  __host__ __device__ __forceinline__
+  transform_pair_of_input_iterators_t(InputIt1 input1_,
+                                      InputIt2 input2_,
+                                      BinaryOp op_)
+      : input1(input1_), input2(input2_), op(op_) {}
+
+#if THRUST_CPP_DIALECT >= 2011
+  transform_pair_of_input_iterators_t(const self_t &) = default;
+#endif
+
+  // BinaryOp might not be copy assignable, such as when it is a lambda.
+  // Define an explicit copy assignment operator that doesn't try to assign it.
+  __host__ __device__
+  self_t& operator=(const self_t& o)
+  {
+    input1 = o.input1;
+    input2 = o.input2;
+    return *this;
+  }
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++input1;
+    ++input2;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++input1;
+    ++input2;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    return op(*input1, *input2);
+  }
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    return op(*input1, *input2);
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(input1 + n, input2 + n, op);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    input1 += n;
+    input2 += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(input1 - n, input2 - n, op);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    input1 -= n;
+    input2 -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return input1 - other.input1;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return op(input1[n], input2[n]);
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (input1 == rhs.input1) && (input2 == rhs.input2);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (input1 != rhs.input1) || (input2 != rhs.input2);
+  }
+
+};    // struct transform_pair_of_input_iterators_t
+
+
+struct identity
+{
+  template <class T>
+  __host__ __device__ T const &
+  operator()(T const &t) const
+  {
+    return t;
+  }
+
+  template <class T>
+  __host__ __device__ T &
+  operator()(T &t) const
+  {
+    return t;
+  }
+};
+
+
+template <class T>
+struct counting_iterator_t
+{
+  typedef counting_iterator_t             self_t;
+  typedef T                               difference_type;
+  typedef T                               value_type;
+  typedef void                            pointer;
+  typedef T                               reference;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  T count;
+
+  __host__ __device__ __forceinline__
+  counting_iterator_t(T count_) : count(count_) {}
+
+  /// Postfix increment
+  __host__ __device__ __forceinline__ self_t operator++(int)
+  {
+    self_t retval = *this;
+    ++count;
+    return retval;
+  }
+
+  /// Prefix increment
+  __host__ __device__ __forceinline__ self_t operator++()
+  {
+    ++count;
+    return *this;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*() const
+  {
+    return count;
+  }
+
+  /// Indirection
+  __host__ __device__ __forceinline__ reference operator*()
+  {
+    return count;
+  }
+
+  /// Addition
+  __host__ __device__ __forceinline__ self_t operator+(difference_type n) const
+  {
+    return self_t(count + n);
+  }
+
+  /// Addition assignment
+  __host__ __device__ __forceinline__ self_t &operator+=(difference_type n)
+  {
+    count += n;
+    return *this;
+  }
+
+  /// Subtraction
+  __host__ __device__ __forceinline__ self_t operator-(difference_type n) const
+  {
+    return self_t(count - n);
+  }
+
+  /// Subtraction assignment
+  __host__ __device__ __forceinline__ self_t &operator-=(difference_type n)
+  {
+    count -= n;
+    return *this;
+  }
+
+  /// Distance
+  __host__ __device__ __forceinline__ difference_type operator-(self_t other) const
+  {
+    return count - other.count;
+  }
+
+  /// Array subscript
+  __host__ __device__ __forceinline__ reference operator[](difference_type n) const
+  {
+    return count + n;
+  }
+
+  /// Equal to
+  __host__ __device__ __forceinline__ bool operator==(const self_t &rhs) const
+  {
+    return (count == rhs.count);
+  }
+
+  /// Not equal to
+  __host__ __device__ __forceinline__ bool operator!=(const self_t &rhs) const
+  {
+    return (count != rhs.count);
+  }
+
+};    // struct count_iterator_t
+
+}    // cuda_
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/error.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/error.h
new file mode 100644
index 0000000000000000000000000000000000000000..b180f8347e055f6ccb2c9945800f6a8c5ca60060
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/error.h
@@ -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.
+ */
+
+
+/*! \file thrust/system/cuda/error.h
+ *  \brief CUDA-specific error reporting
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/system/error_code.h>
+#include <thrust/system/cuda/detail/guarded_driver_types.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+namespace cuda
+{
+
+// To construct an error_code after a CUDA Runtime error:
+//
+//   error_code(::cudaGetLastError(), cuda_category())
+
+// XXX N3000 prefers enum class errc { ... }
+/*! Namespace for CUDA Runtime errors.
+ */
+namespace errc
+{
+
+/*! \p errc_t enumerates the kinds of CUDA Runtime errors.
+ */
+enum errc_t
+{
+  // from cuda/include/driver_types.h
+  // mirror their order
+  success                            = cudaSuccess,
+  missing_configuration              = cudaErrorMissingConfiguration,
+  memory_allocation                  = cudaErrorMemoryAllocation,
+  initialization_error               = cudaErrorInitializationError,
+  launch_failure                     = cudaErrorLaunchFailure,
+  launch_timeout                     = cudaErrorLaunchTimeout,
+  launch_out_of_resources            = cudaErrorLaunchOutOfResources,
+  invalid_device_function            = cudaErrorInvalidDeviceFunction,
+  invalid_configuration              = cudaErrorInvalidConfiguration,
+  invalid_device                     = cudaErrorInvalidDevice,
+  invalid_value                      = cudaErrorInvalidValue,
+  invalid_pitch_value                = cudaErrorInvalidPitchValue,
+  invalid_symbol                     = cudaErrorInvalidSymbol,
+  map_buffer_object_failed           = cudaErrorMapBufferObjectFailed,
+  unmap_buffer_object_failed         = cudaErrorUnmapBufferObjectFailed,
+  invalid_texture                    = cudaErrorInvalidTexture,
+  invalid_texture_binding            = cudaErrorInvalidTextureBinding,
+  invalid_channel_descriptor         = cudaErrorInvalidChannelDescriptor,
+  invalid_memcpy_direction           = cudaErrorInvalidMemcpyDirection,
+  invalid_filter_setting             = cudaErrorInvalidFilterSetting,
+  invalid_norm_setting               = cudaErrorInvalidNormSetting,
+  cuda_runtime_unloading             = cudaErrorCudartUnloading,
+  unknown                            = cudaErrorUnknown,
+  invalid_resource_handle            = cudaErrorInvalidResourceHandle,
+  not_ready                          = cudaErrorNotReady,
+  insufficient_driver                = cudaErrorInsufficientDriver,
+  set_on_active_process_error        = cudaErrorSetOnActiveProcess,
+  no_device                          = cudaErrorNoDevice,
+  ecc_uncorrectable                  = cudaErrorECCUncorrectable,
+
+#if CUDART_VERSION >= 4020
+  shared_object_symbol_not_found     = cudaErrorSharedObjectSymbolNotFound,
+  shared_object_init_failed          = cudaErrorSharedObjectInitFailed,
+  unsupported_limit                  = cudaErrorUnsupportedLimit,
+  duplicate_variable_name            = cudaErrorDuplicateVariableName,
+  duplicate_texture_name             = cudaErrorDuplicateTextureName,
+  duplicate_surface_name             = cudaErrorDuplicateSurfaceName,
+  devices_unavailable                = cudaErrorDevicesUnavailable,
+  invalid_kernel_image               = cudaErrorInvalidKernelImage,
+  no_kernel_image_for_device         = cudaErrorNoKernelImageForDevice,
+  incompatible_driver_context        = cudaErrorIncompatibleDriverContext,
+  peer_access_already_enabled        = cudaErrorPeerAccessAlreadyEnabled,
+  peer_access_not_enabled            = cudaErrorPeerAccessNotEnabled,
+  device_already_in_use              = cudaErrorDeviceAlreadyInUse,
+  profiler_disabled                  = cudaErrorProfilerDisabled,
+  assert_triggered                   = cudaErrorAssert,
+  too_many_peers                     = cudaErrorTooManyPeers,
+  host_memory_already_registered     = cudaErrorHostMemoryAlreadyRegistered,
+  host_memory_not_registered         = cudaErrorHostMemoryNotRegistered,
+  operating_system_error             = cudaErrorOperatingSystem,
+#endif
+
+#if CUDART_VERSION >= 5000
+  peer_access_unsupported            = cudaErrorPeerAccessUnsupported,
+  launch_max_depth_exceeded          = cudaErrorLaunchMaxDepthExceeded,
+  launch_file_scoped_texture_used    = cudaErrorLaunchFileScopedTex,
+  launch_file_scoped_surface_used    = cudaErrorLaunchFileScopedSurf,
+  sync_depth_exceeded                = cudaErrorSyncDepthExceeded,
+  attempted_operation_not_permitted  = cudaErrorNotPermitted,
+  attempted_operation_not_supported  = cudaErrorNotSupported,
+#endif
+
+  startup_failure                    = cudaErrorStartupFailure
+}; // end errc_t
+
+
+} // end namespace errc
+
+} // end namespace cuda_cub
+
+/*! \return A reference to an object of a type derived from class \p thrust::error_category.
+ *  \note The object's \p equivalent virtual functions shall behave as specified
+ *        for the class \p thrust::error_category. The object's \p name virtual function shall
+ *        return a pointer to the string <tt>"cuda"</tt>. The object's
+ *        \p default_error_condition virtual function shall behave as follows:
+ *
+ *        If the argument <tt>ev</tt> corresponds to a CUDA error value, the function
+ *        shall return <tt>error_condition(ev,cuda_category())</tt>.
+ *        Otherwise, the function shall return <tt>system_category.default_error_condition(ev)</tt>.
+ */
+inline const error_category &cuda_category(void);
+
+
+// XXX N3000 prefers is_error_code_enum<cuda::errc>
+
+/*! Specialization of \p is_error_code_enum for \p cuda::errc::errc_t
+ */
+template<> struct is_error_code_enum<cuda::errc::errc_t> : thrust::detail::true_type {};
+
+
+// XXX replace cuda::errc::errc_t with cuda::errc upon c++0x
+/*! \return <tt>error_code(static_cast<int>(e), cuda::error_category())</tt>
+ */
+inline error_code make_error_code(cuda::errc::errc_t e);
+
+
+// XXX replace cuda::errc::errc_t with cuda::errc upon c++0x
+/*! \return <tt>error_condition(static_cast<int>(e), cuda::error_category())</tt>.
+ */
+inline error_condition make_error_condition(cuda::errc::errc_t e);
+
+} // end system
+
+namespace cuda_cub
+{
+namespace errc = system::cuda::errc;
+} // end cuda_cub
+
+namespace cuda
+{
+// XXX replace with using system::cuda_errc upon c++0x
+namespace errc = system::cuda::errc;
+} // end cuda
+
+using system::cuda_category;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cuda/detail/error.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/execution_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/execution_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..c171ac3d9692dffb79c01951ac8923f0b634acfc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/execution_policy.h
@@ -0,0 +1,31 @@
+/******************************************************************************
+ * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * 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.
+ *     * Neither the name of the NVIDIA CORPORATION nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 NVIDIA CORPORATION 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.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/system/cuda/detail/par.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/future.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/future.h
new file mode 100644
index 0000000000000000000000000000000000000000..79bfc9134d4ba2313b26576b4bcba8c21e614b0a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/future.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/system/cuda/pointer.h>
+#include <thrust/system/cuda/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system { namespace cuda
+{
+
+struct ready_event;
+
+template <typename T>
+struct ready_future;
+
+struct unique_eager_event;
+
+template <typename T>
+struct unique_eager_future;
+
+template <typename... Events>
+__host__
+unique_eager_event when_all(Events&&... evs);
+
+}} // namespace system::cuda
+
+namespace cuda
+{
+
+using thrust::system::cuda::ready_event;
+
+using thrust::system::cuda::ready_future;
+
+using thrust::system::cuda::unique_eager_event;
+using event = unique_eager_event;
+
+using thrust::system::cuda::unique_eager_future;
+template <typename T> using future = unique_eager_future<T>;
+
+using thrust::system::cuda::when_all;
+
+} // namespace cuda
+
+template <typename DerivedPolicy>
+__host__ 
+thrust::cuda::unique_eager_event
+unique_eager_event_type(
+  thrust::cuda::execution_policy<DerivedPolicy> const&
+) noexcept;
+
+template <typename T, typename DerivedPolicy>
+__host__ 
+thrust::cuda::unique_eager_future<T>
+unique_eager_future_type(
+  thrust::cuda::execution_policy<DerivedPolicy> const&
+) noexcept;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cuda/detail/future.inl>
+
+#endif // C++14
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb8020adb9e9c5401ac71754e448909cabe22869
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory.h
@@ -0,0 +1,109 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/system/cuda/memory.h
+ *  \brief Managing memory associated with Thrust's CUDA system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/memory_resource.h>
+#include <thrust/memory.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/mr/allocator.h>
+#include <ostream>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+
+/*! Allocates an area of memory available to Thrust's <tt>cuda</tt> system.
+ *  \param n Number of bytes to allocate.
+ *  \return A <tt>cuda::pointer<void></tt> pointing to the beginning of the newly
+ *          allocated memory. A null <tt>cuda::pointer<void></tt> is returned if
+ *          an error occurs.
+ *  \note The <tt>cuda::pointer<void></tt> returned by this function must be
+ *        deallocated with \p cuda::free.
+ *  \see cuda::free
+ *  \see std::malloc
+ */
+inline __host__ __device__ pointer<void> malloc(std::size_t n);
+
+/*! Allocates a typed area of memory available to Thrust's <tt>cuda</tt> system.
+ *  \param n Number of elements to allocate.
+ *  \return A <tt>cuda::pointer<T></tt> pointing to the beginning of the newly
+ *          allocated elements. A null <tt>cuda::pointer<T></tt> is returned if
+ *          an error occurs.
+ *  \note The <tt>cuda::pointer<T></tt> returned by this function must be
+ *        deallocated with \p cuda::free.
+ *  \see cuda::free
+ *  \see std::malloc
+ */
+template <typename T>
+inline __host__ __device__ pointer<T> malloc(std::size_t n);
+
+/*! Deallocates an area of memory previously allocated by <tt>cuda::malloc</tt>.
+ *  \param ptr A <tt>cuda::pointer<void></tt> pointing to the beginning of an area
+ *         of memory previously allocated with <tt>cuda::malloc</tt>.
+ *  \see cuda::malloc
+ *  \see std::free
+ */
+inline __host__ __device__ void free(pointer<void> ptr);
+
+/*! \p cuda::allocator is the default allocator used by the \p cuda system's
+ *  containers such as <tt>cuda::vector</tt> if no user-specified allocator is
+ *  provided. \p cuda::allocator allocates (deallocates) storage with \p
+ *  cuda::malloc (\p cuda::free).
+ */
+template<typename T>
+using allocator = thrust::mr::stateless_resource_allocator<
+  T, thrust::system::cuda::memory_resource
+>;
+
+/*! \p cuda::universal_allocator allocates memory that can be used by the \p cuda
+ *  system and host systems.
+ */
+template<typename T>
+using universal_allocator = thrust::mr::stateless_resource_allocator<
+  T, thrust::system::cuda::universal_memory_resource
+>;
+
+} // namespace cuda_cub
+
+namespace system { namespace cuda
+{
+using thrust::cuda_cub::malloc;
+using thrust::cuda_cub::free;
+using thrust::cuda_cub::allocator;
+using thrust::cuda_cub::universal_allocator;
+}} // namespace system::cuda
+
+/*! \namespace thrust::cuda
+ *  \brief \p thrust::cuda is a top-level alias for \p thrust::system::cuda.
+ */
+namespace cuda
+{
+using thrust::cuda_cub::malloc;
+using thrust::cuda_cub::free;
+using thrust::cuda_cub::allocator;
+using thrust::cuda_cub::universal_allocator;
+} // namespace cuda
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/cuda/detail/memory.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory_resource.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bf534e401e359134b5cc291743af4962794446f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/memory_resource.h
@@ -0,0 +1,126 @@
+/*
+ *  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.
+ */
+
+/*! \file cuda/memory_resource.h
+ *  \brief Memory resources for the CUDA system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/mr/memory_resource.h>
+#include <thrust/system/cuda/detail/guarded_cuda_runtime_api.h>
+#include <thrust/system/cuda/pointer.h>
+#include <thrust/system/detail/bad_alloc.h>
+#include <thrust/system/cuda/error.h>
+#include <thrust/system/cuda/detail/util.h>
+
+#include <thrust/mr/host_memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+namespace cuda
+{
+
+//! \cond
+namespace detail
+{
+
+    typedef cudaError_t (CUDARTAPI *allocation_fn)(void **, std::size_t);
+    typedef cudaError_t (CUDARTAPI *deallocation_fn)(void *);
+
+    template<allocation_fn Alloc, deallocation_fn Dealloc, typename Pointer>
+    class cuda_memory_resource final : public mr::memory_resource<Pointer>
+    {
+    public:
+        Pointer do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
+        {
+            (void)alignment;
+
+            void * ret;
+            cudaError_t status = Alloc(&ret, bytes);
+
+            if (status != cudaSuccess)
+            {
+                cudaGetLastError(); // Clear the CUDA global error state.
+                throw thrust::system::detail::bad_alloc(thrust::cuda_category().message(status).c_str());
+            }
+
+            return Pointer(ret);
+        }
+
+        void do_deallocate(Pointer p, std::size_t bytes, std::size_t alignment) override
+        {
+            (void)bytes;
+            (void)alignment;
+
+            cudaError_t status = Dealloc(thrust::detail::pointer_traits<Pointer>::get(p));
+
+            if (status != cudaSuccess)
+            {
+                thrust::cuda_cub::throw_on_error(status, "CUDA free failed");
+            }
+        }
+    };
+
+    inline cudaError_t CUDARTAPI cudaMallocManaged(void ** ptr, std::size_t bytes)
+    {
+        return ::cudaMallocManaged(ptr, bytes, cudaMemAttachGlobal);
+    }
+
+    typedef detail::cuda_memory_resource<cudaMalloc, cudaFree,
+        thrust::cuda::pointer<void> >
+        device_memory_resource;
+    typedef detail::cuda_memory_resource<detail::cudaMallocManaged, cudaFree,
+        thrust::cuda::universal_pointer<void> >
+        managed_memory_resource;
+    typedef detail::cuda_memory_resource<cudaMallocHost, cudaFreeHost,
+        thrust::cuda::universal_pointer<void> >
+        pinned_memory_resource;
+
+} // end detail
+//! \endcond
+
+/*! The memory resource for the CUDA system. Uses <tt>cudaMalloc</tt> and wraps
+ *  the result with \p cuda::pointer.
+ */
+typedef detail::device_memory_resource memory_resource;
+/*! The universal memory resource for the CUDA system. Uses
+ *  <tt>cudaMallocManaged</tt> and wraps the result with
+ *  \p cuda::universal_pointer.
+ */
+typedef detail::managed_memory_resource universal_memory_resource;
+/*! The host pinned memory resource for the CUDA system. Uses
+ *  <tt>cudaMallocHost</tt> and wraps the result with \p
+ *  cuda::universal_pointer.
+ */
+typedef detail::pinned_memory_resource universal_host_pinned_memory_resource;
+
+} // end cuda
+} // end system
+
+namespace cuda
+{
+using thrust::system::cuda::memory_resource;
+using thrust::system::cuda::universal_memory_resource;
+using thrust::system::cuda::universal_host_pinned_memory_resource;
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/pointer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/pointer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ace77fbaef4d8e713a9e80c8f3ce3dce53dbdf0f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/pointer.h
@@ -0,0 +1,137 @@
+/*
+ *  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.
+ */
+
+/*! \file thrust/system/cuda/memory.h
+ *  \brief Managing memory associated with Thrust's Standard C++ system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <type_traits>
+#include <thrust/system/cuda/detail/execution_policy.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/reference.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+
+/*! \p cuda::pointer stores a pointer to an object allocated in memory
+ *  accessible by the \p cuda system. This type provides type safety when
+ *  dispatching algorithms on ranges resident in \p cuda memory.
+ *
+ *  \p cuda::pointer has pointer semantics: it may be dereferenced and
+ *  manipulated with pointer arithmetic.
+ *
+ *  \p cuda::pointer can be created with the function \p cuda::malloc, or by
+ *  explicitly calling its constructor with a raw pointer.
+ *
+ *  The raw pointer encapsulated by a \p cuda::pointer may be obtained by eiter
+ *  its <tt>get</tt> member function or the \p raw_pointer_cast function.
+ *
+ *  \note \p cuda::pointer is not a "smart" pointer; it is the programmer's
+ *        responsibility to deallocate memory pointed to by \p cuda::pointer.
+ *
+ *  \tparam T specifies the type of the pointee.
+ *
+ *  \see cuda::malloc
+ *  \see cuda::free
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+using pointer = thrust::pointer<
+  T,
+  thrust::cuda_cub::tag,
+  thrust::tagged_reference<T, thrust::cuda_cub::tag>
+>;
+
+/*! \p cuda::universal_pointer stores a pointer to an object allocated in
+ *  memory accessible by the \p cuda system and host systems.
+ *
+ *  \p cuda::universal_pointer has pointer semantics: it may be dereferenced
+ *  and manipulated with pointer arithmetic.
+ *
+ *  \p cuda::universal_pointer can be created with \p cuda::universal_allocator
+ *  or by explicitly calling its constructor with a raw pointer.
+ *
+ *  The raw pointer encapsulated by a \p cuda::universal_pointer may be
+ *  obtained by eiter its <tt>get</tt> member function or the \p
+ *  raw_pointer_cast function.
+ *
+ *  \note \p cuda::universal_pointer is not a "smart" pointer; it is the
+ *        programmer's responsibility to deallocate memory pointed to by
+ *        \p cuda::universal_pointer.
+ *
+ *  \tparam T specifies the type of the pointee.
+ *
+ *  \see cuda::universal_allocator
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+using universal_pointer = thrust::pointer<
+  T,
+  thrust::cuda_cub::tag,
+  typename std::add_lvalue_reference<T>::type
+>;
+
+/*! \p cuda::reference is a wrapped reference to an object stored in memory
+ *  accessible by the \p cuda system. \p cuda::reference is the type of the
+ *  result of dereferencing a \p cuda::pointer.
+ *
+ *  \tparam T Specifies the type of the referenced object.
+ *
+ *  \see cuda::pointer
+ */
+template <typename T>
+using reference = thrust::tagged_reference<T, thrust::cuda_cub::tag>;
+
+} // namespace cuda_cub
+
+/*! \addtogroup system_backends Systems
+ *  \ingroup system
+ *  \{
+ */
+
+/*! \namespace thrust::system::cuda
+ *  \brief \p thrust::system::cuda is the namespace containing functionality
+ *  for allocating, manipulating, and deallocating memory available to Thrust's
+ *  CUDA backend system. The identifiers are provided in a separate namespace
+ *  underneath \p thrust::system for import convenience but are also
+ *  aliased in the top-level <tt>thrust::cuda</tt> namespace for easy access.
+ *
+ */
+namespace system { namespace cuda
+{
+using thrust::cuda_cub::pointer;
+using thrust::cuda_cub::universal_pointer;
+using thrust::cuda_cub::reference;
+}} // namespace system::cuda
+/*! \}
+ */
+
+/*! \namespace thrust::cuda
+ *  \brief \p thrust::cuda is a top-level alias for \p thrust::system::cuda.
+ */
+namespace cuda
+{
+using thrust::cuda_cub::pointer;
+using thrust::cuda_cub::universal_pointer;
+using thrust::cuda_cub::reference;
+} // namespace cuda
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/vector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..fafc7bf17e39da0fc155988d0d61217f7032246c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/cuda/vector.h
@@ -0,0 +1,89 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/system/cuda/vector.h
+ *  \brief A dynamically-sizable array of elements which reside in memory available to
+ *         Thrust's CUDA system.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cuda/memory.h>
+#include <thrust/detail/vector_base.h>
+#include <vector>
+
+THRUST_NAMESPACE_BEGIN
+namespace cuda_cub
+{
+
+/*! \p cuda::vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p cuda::vector may vary dynamically; memory management is
+ *  automatic. The elements contained in a \p cuda::vector reside in memory
+ *  accessible by the \p cuda system.
+ *
+ *  \tparam T The element type of the \p cuda::vector.
+ *  \tparam Allocator The allocator type of the \p cuda::vector.
+ *          Defaults to \p cuda::allocator.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see host_vector For the documentation of the complete interface which is
+ *                   shared by \p cuda::vector
+ *  \see device_vector
+ *  \see universal_vector
+ */
+template <typename T, typename Allocator = thrust::system::cuda::allocator<T>>
+using vector = thrust::detail::vector_base<T, Allocator>;
+
+/*! \p cuda::universal_vector is a container that supports random access to
+ *  elements, constant time removal of elements at the end, and linear time
+ *  insertion and removal of elements at the beginning or in the middle. The
+ *  number of elements in a \p cuda::universal_vector may vary dynamically;
+ *  memory management is automatic. The elements contained in a
+ *  \p cuda::universal_vector reside in memory accessible by the \p cuda system
+ *  and host systems.
+ *
+ *  \tparam T The element type of the \p cuda::universal_vector.
+ *  \tparam Allocator The allocator type of the \p cuda::universal_vector.
+ *          Defaults to \p cuda::universal_allocator.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see host_vector For the documentation of the complete interface which is
+ *                   shared by \p cuda::universal_vector
+ *  \see device_vector
+ *  \see universal_vector
+ */
+template <typename T, typename Allocator = thrust::system::cuda::universal_allocator<T>>
+using universal_vector = thrust::detail::vector_base<T, Allocator>;
+
+} // namespace cuda_cub
+
+namespace system { namespace cuda
+{
+using thrust::cuda_cub::vector;
+using thrust::cuda_cub::universal_vector;
+}}
+
+namespace cuda
+{
+using thrust::cuda_cub::vector;
+using thrust::cuda_cub::universal_vector;
+}
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/adjacent_difference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/adjacent_difference.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6f6c72820a2fe158d7389d03d49334e1675438b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/adjacent_difference.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the adjacent_difference.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch adjacent_difference
+
+#include <thrust/system/detail/sequential/adjacent_difference.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/adjacent_difference.h>
+#include <thrust/system/cuda/detail/adjacent_difference.h>
+#include <thrust/system/omp/detail/adjacent_difference.h>
+#include <thrust/system/tbb/detail/adjacent_difference.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/adjacent_difference.h>
+#include __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+#undef __THRUST_HOST_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/adjacent_difference.h>
+#include __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ADJACENT_DIFFERENCE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/assign_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/assign_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..d38934affd1a0a51fb64e011106b9af83dca8cdb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/assign_value.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the assign_value.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch assign_value
+
+#include <thrust/system/detail/sequential/assign_value.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/assign_value.h>
+#include <thrust/system/cuda/detail/assign_value.h>
+#include <thrust/system/omp/detail/assign_value.h>
+#include <thrust/system/tbb/detail/assign_value.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/assign_value.h>
+#include __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER
+#undef __THRUST_HOST_SYSTEM_ASSIGN_VALUE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/assign_value.h>
+#include __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASSIGN_VALUE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/binary_search.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/binary_search.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f9ac06df9bce42d261cf650b143d6389734988e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/binary_search.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the binary_search.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch binary_search
+
+#include <thrust/system/detail/sequential/binary_search.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/binary_search.h>
+#include <thrust/system/cuda/detail/binary_search.h>
+#include <thrust/system/omp/detail/binary_search.h>
+#include <thrust/system/tbb/detail/binary_search.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/binary_search.h>
+#include __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER
+#undef __THRUST_HOST_SYSTEM_BINARY_SEARCH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/binary_search.h>
+#include __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_BINARY_SEARCH_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..0035b83efee0265e87fdc34f76c66c1f62d1cf60
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the copy.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch copy
+
+#include <thrust/system/detail/sequential/copy.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/copy.h>
+#include <thrust/system/cuda/detail/copy.h>
+#include <thrust/system/omp/detail/copy.h>
+#include <thrust/system/tbb/detail/copy.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COPY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/copy.h>
+#include __THRUST_HOST_SYSTEM_COPY_HEADER
+#undef __THRUST_HOST_SYSTEM_COPY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COPY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/copy.h>
+#include __THRUST_DEVICE_SYSTEM_COPY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COPY_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy_if.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy_if.h
new file mode 100644
index 0000000000000000000000000000000000000000..31adaf8e1a7366071924404561873a1cf6b89042
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/copy_if.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy_if.h 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>
+
+// the purpose of this header is to #include the copy_if.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch copy_if
+
+#include <thrust/system/detail/sequential/copy_if.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/copy_if.h>
+#include <thrust/system/cuda/detail/copy_if.h>
+#include <thrust/system/omp/detail/copy_if.h>
+#include <thrust/system/tbb/detail/copy_if.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COPY_IF_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/copy_if.h>
+#include __THRUST_HOST_SYSTEM_COPY_IF_HEADER
+#undef __THRUST_HOST_SYSTEM_COPY_IF_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/copy_if.h>
+#include __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COPY_IF_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/count.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d6f1f748ffea9d1b3a33c764cc2ac307b51a5f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/count.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a count 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>
+
+// the purpose of this header is to #include the count.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch count
+
+#include <thrust/system/detail/sequential/count.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/count.h>
+#include <thrust/system/cuda/detail/count.h>
+#include <thrust/system/omp/detail/count.h>
+#include <thrust/system/tbb/detail/count.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_COUNT_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/count.h>
+#include __THRUST_HOST_SYSTEM_COUNT_HEADER
+#undef __THRUST_HOST_SYSTEM_COUNT_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_COUNT_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/count.h>
+#include __THRUST_DEVICE_SYSTEM_COUNT_HEADER
+#undef __THRUST_DEVICE_SYSTEM_COUNT_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/equal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/equal.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b02e33b857eb9d7efae5747cc9bcbde6b8c0b17
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/equal.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a equal 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>
+
+// the purpose of this header is to #include the equal.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch equal
+
+#include <thrust/system/detail/sequential/equal.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/equal.h>
+#include <thrust/system/cuda/detail/equal.h>
+#include <thrust/system/omp/detail/equal.h>
+#include <thrust/system/tbb/detail/equal.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_EQUAL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/equal.h>
+#include __THRUST_HOST_SYSTEM_EQUAL_HEADER
+#undef __THRUST_HOST_SYSTEM_EQUAL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_EQUAL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/equal.h>
+#include __THRUST_DEVICE_SYSTEM_EQUAL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EQUAL_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/extrema.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/extrema.h
new file mode 100644
index 0000000000000000000000000000000000000000..62fb39be922d5dd0eb0be84b513ace96bcad3e7d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/extrema.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a extrema 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>
+
+// the purpose of this header is to #include the extrema.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch extrema
+
+#include <thrust/system/detail/sequential/extrema.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/extrema.h>
+#include <thrust/system/cuda/detail/extrema.h>
+#include <thrust/system/omp/detail/extrema.h>
+#include <thrust/system/tbb/detail/extrema.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_EXTREMA_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/extrema.h>
+#include __THRUST_HOST_SYSTEM_EXTREMA_HEADER
+#undef __THRUST_HOST_SYSTEM_EXTREMA_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/extrema.h>
+#include __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER
+#undef __THRUST_DEVICE_SYSTEM_EXTREMA_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..f76a81b4f3477d87abe5b88c71f89e4158d68d28
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/fill.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the fill.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch fill
+
+#include <thrust/system/detail/sequential/fill.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/fill.h>
+#include <thrust/system/cuda/detail/fill.h>
+#include <thrust/system/omp/detail/fill.h>
+#include <thrust/system/tbb/detail/fill.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FILL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/fill.h>
+#include __THRUST_HOST_SYSTEM_FILL_HEADER
+#undef __THRUST_HOST_SYSTEM_FILL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FILL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/fill.h>
+#include __THRUST_DEVICE_SYSTEM_FILL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FILL_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/find.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/find.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d85e09a3ab713bfa9dd668bb0beb791cfc3db1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/find.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the find.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch find
+
+#include <thrust/system/detail/sequential/find.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/find.h>
+#include <thrust/system/cuda/detail/find.h>
+#include <thrust/system/omp/detail/find.h>
+#include <thrust/system/tbb/detail/find.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FIND_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/find.h>
+#include __THRUST_HOST_SYSTEM_FIND_HEADER
+#undef __THRUST_HOST_SYSTEM_FIND_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FIND_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/find.h>
+#include __THRUST_DEVICE_SYSTEM_FIND_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FIND_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/for_each.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/for_each.h
new file mode 100644
index 0000000000000000000000000000000000000000..8509edca3630f2c9d313e34efeca10abbee03e7b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/for_each.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the for_each.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch for_each
+
+#include <thrust/system/detail/sequential/for_each.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/for_each.h>
+#include <thrust/system/cuda/detail/for_each.h>
+#include <thrust/system/omp/detail/for_each.h>
+#include <thrust/system/tbb/detail/for_each.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_FOR_EACH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/for_each.h>
+#include __THRUST_HOST_SYSTEM_FOR_EACH_HEADER
+#undef __THRUST_HOST_SYSTEM_FOR_EACH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/for_each.h>
+#include __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_FOR_EACH_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/gather.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..242da3c9095757a2c7de9e0b97ae5fe4118c8172
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/gather.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the gather.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch gather
+
+#include <thrust/system/detail/sequential/gather.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/gather.h>
+#include <thrust/system/cuda/detail/gather.h>
+#include <thrust/system/omp/detail/gather.h>
+#include <thrust/system/tbb/detail/gather.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_GATHER_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/gather.h>
+#include __THRUST_HOST_SYSTEM_GATHER_HEADER
+#undef __THRUST_HOST_SYSTEM_GATHER_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_GATHER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/gather.h>
+#include __THRUST_DEVICE_SYSTEM_GATHER_HEADER
+#undef __THRUST_DEVICE_SYSTEM_GATHER_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/generate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/generate.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b1d7b4bac5f24a40072e461d9bce530dfa12319
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/generate.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the generate.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch generate
+
+#include <thrust/system/detail/sequential/generate.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/generate.h>
+#include <thrust/system/cuda/detail/generate.h>
+#include <thrust/system/omp/detail/generate.h>
+#include <thrust/system/tbb/detail/generate.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_GENERATE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/generate.h>
+#include __THRUST_HOST_SYSTEM_GENERATE_HEADER
+#undef __THRUST_HOST_SYSTEM_GENERATE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_GENERATE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/generate.h>
+#include __THRUST_DEVICE_SYSTEM_GENERATE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_GENERATE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/get_value.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/get_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..306eb423eb4b1bc55c01c12eca0087a95b0ff376
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/get_value.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the get_value.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch get_value
+
+#include <thrust/system/detail/sequential/get_value.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/get_value.h>
+#include <thrust/system/cuda/detail/get_value.h>
+#include <thrust/system/omp/detail/get_value.h>
+#include <thrust/system/tbb/detail/get_value.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_GET_VALUE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/get_value.h>
+#include __THRUST_HOST_SYSTEM_GET_VALUE_HEADER
+#undef __THRUST_HOST_SYSTEM_GET_VALUE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/get_value.h>
+#include __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_GET_VALUE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/inner_product.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/inner_product.h
new file mode 100644
index 0000000000000000000000000000000000000000..9423b1bdbf19deba9f7ec91d9ce4417b0c2f5145
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/inner_product.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the inner_product.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch inner_product
+
+#include <thrust/system/detail/sequential/inner_product.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/inner_product.h>
+#include <thrust/system/cuda/detail/inner_product.h>
+#include <thrust/system/omp/detail/inner_product.h>
+#include <thrust/system/tbb/detail/inner_product.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_INNER_PRODUCT_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/inner_product.h>
+#include __THRUST_HOST_SYSTEM_INNER_PRODUCT_HEADER
+#undef __THRUST_HOST_SYSTEM_INNER_PRODUCT_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_INNER_PRODUCT_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/inner_product.h>
+#include __THRUST_DEVICE_SYSTEM_INNER_PRODUCT_HEADER
+#undef __THRUST_DEVICE_SYSTEM_INNER_PRODUCT_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/iter_swap.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/iter_swap.h
new file mode 100644
index 0000000000000000000000000000000000000000..d9da52a6274c151e8602f41b72a0a9dafed13c26
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/iter_swap.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the iter_swap.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch iter_swap
+
+#include <thrust/system/detail/sequential/iter_swap.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/iter_swap.h>
+#include <thrust/system/cuda/detail/iter_swap.h>
+#include <thrust/system/omp/detail/iter_swap.h>
+#include <thrust/system/tbb/detail/iter_swap.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_ITER_SWAP_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/iter_swap.h>
+#include __THRUST_HOST_SYSTEM_ITER_SWAP_HEADER
+#undef __THRUST_HOST_SYSTEM_ITER_SWAP_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ITER_SWAP_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/iter_swap.h>
+#include __THRUST_DEVICE_SYSTEM_ITER_SWAP_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ITER_SWAP_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/logical.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/logical.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdaad4d293a2695f0a1218e0cf828eb12406ad16
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/logical.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the logical.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch logical
+
+#include <thrust/system/detail/sequential/logical.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/logical.h>
+#include <thrust/system/cuda/detail/logical.h>
+#include <thrust/system/omp/detail/logical.h>
+#include <thrust/system/tbb/detail/logical.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_LOGICAL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/logical.h>
+#include __THRUST_HOST_SYSTEM_LOGICAL_HEADER
+#undef __THRUST_HOST_SYSTEM_LOGICAL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/logical.h>
+#include __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_LOGICAL_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/malloc_and_free.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/malloc_and_free.h
new file mode 100644
index 0000000000000000000000000000000000000000..c36db0270ddfd2ee2b56f2fa04272b6dcbce8796
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/malloc_and_free.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// the purpose of this header is to #include the malloc_and_free.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch malloc_and_free
+
+#include <thrust/system/detail/sequential/malloc_and_free.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/malloc_and_free.h>
+#include <thrust/system/cuda/detail/malloc_and_free.h>
+#include <thrust/system/omp/detail/malloc_and_free.h>
+#include <thrust/system/tbb/detail/malloc_and_free.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_MALLOC_AND_FREE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/malloc_and_free.h>
+#include __THRUST_HOST_SYSTEM_MALLOC_AND_FREE_HEADER
+#undef __THRUST_HOST_SYSTEM_MALLOC_AND_FREE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_MALLOC_AND_FREE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/malloc_and_free.h>
+#include __THRUST_DEVICE_SYSTEM_MALLOC_AND_FREE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MALLOC_AND_FREE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/merge.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/merge.h
new file mode 100644
index 0000000000000000000000000000000000000000..7abca9bcf3f1697196277c40c4718c2c5004de9a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/merge.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the merge.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch merge
+
+#include <thrust/system/detail/sequential/merge.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/merge.h>
+#include <thrust/system/cuda/detail/merge.h>
+#include <thrust/system/omp/detail/merge.h>
+#include <thrust/system/tbb/detail/merge.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_MERGE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/merge.h>
+#include __THRUST_HOST_SYSTEM_MERGE_HEADER
+#undef __THRUST_HOST_SYSTEM_MERGE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_MERGE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/merge.h>
+#include __THRUST_DEVICE_SYSTEM_MERGE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MERGE_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/mismatch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/mismatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..74feb826928851a2d09e92cb5403dc0375cda288
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/mismatch.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the mismatch.h header
+// of the host and device systems. It should be #included in any
+// code which uses adl to dispatch mismatch
+
+#include <thrust/system/detail/sequential/mismatch.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/mismatch.h>
+#include <thrust/system/cuda/detail/mismatch.h>
+#include <thrust/system/omp/detail/mismatch.h>
+#include <thrust/system/tbb/detail/mismatch.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_MISMATCH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/mismatch.h>
+#include __THRUST_HOST_SYSTEM_MISMATCH_HEADER
+#undef __THRUST_HOST_SYSTEM_MISMATCH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_MISMATCH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/mismatch.h>
+#include __THRUST_DEVICE_SYSTEM_MISMATCH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MISMATCH_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/partition.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/partition.h
new file mode 100644
index 0000000000000000000000000000000000000000..a45f845a5c6ec5bc0016bdfb823e3b9b3d695276
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/partition.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a fill 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>
+
+// the purpose of this header is to #include the partition.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch partition
+
+#include <thrust/system/detail/sequential/partition.h>
+
+// SCons can't see through the #defines below to figure out what this header
+// includes, so we fake it out by specifying all possible files we might end up
+// including inside an #if 0.
+#if 0
+#include <thrust/system/cpp/detail/partition.h>
+#include <thrust/system/cuda/detail/partition.h>
+#include <thrust/system/omp/detail/partition.h>
+#include <thrust/system/tbb/detail/partition.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_PARTITION_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/partition.h>
+#include __THRUST_HOST_SYSTEM_PARTITION_HEADER
+#undef __THRUST_HOST_SYSTEM_PARTITION_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_PARTITION_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/partition.h>
+#include __THRUST_DEVICE_SYSTEM_PARTITION_HEADER
+#undef __THRUST_DEVICE_SYSTEM_PARTITION_HEADER
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/bad_alloc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/bad_alloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae5dd5994ef59eb2299754b8ffd8785411a37007
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/bad_alloc.h
@@ -0,0 +1,58 @@
+/*
+ *  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 <new>
+#include <string>
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+
+// define our own bad_alloc so we can set its .what()
+class bad_alloc
+  : public std::bad_alloc
+{
+  public:
+    inline bad_alloc(const std::string &w)
+      : std::bad_alloc(), m_what()
+    {
+      m_what = std::bad_alloc::what();
+      m_what += ": ";
+      m_what += w;
+    } // end bad_alloc()
+
+    inline virtual ~bad_alloc(void) noexcept {};
+
+    inline virtual const char *what(void) const noexcept
+    {
+      return m_what.c_str();
+    } // end what()
+
+  private:
+    std::string m_what;
+}; // end bad_alloc
+  
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/errno.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/errno.h
new file mode 100644
index 0000000000000000000000000000000000000000..69cb2bd98062e9166a01236ae78d22b4cf42ddfa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/errno.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.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// The rationale for the existence of these apparently redundant definitions is
+// to provide them portably and to avoid bringing in system headers which might
+// pollute the global namespace. These identifiers are in lowercase to avoid
+// colliding with the real macros in errno.h.
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+namespace detail
+{
+
+static const int eafnosupport    = 9901;
+static const int eaddrinuse      = 9902;
+static const int eaddrnotavail   = 9903;
+static const int eisconn         = 9904;
+static const int ebadmsg         = 9905;
+static const int econnaborted    = 9906;
+static const int ealready        = 9907;
+static const int econnrefused    = 9908;
+static const int econnreset      = 9909;
+static const int edestaddrreq    = 9910;
+static const int ehostunreach    = 9911;
+static const int eidrm           = 9912;
+static const int emsgsize        = 9913;
+static const int enetdown        = 9914;
+static const int enetreset       = 9915;
+static const int enetunreach     = 9916;
+static const int enobufs         = 9917;
+static const int enolink         = 9918;
+static const int enodata         = 9919;
+static const int enomsg          = 9920;
+static const int enoprotoopt     = 9921;
+static const int enosr           = 9922;
+static const int enotsock        = 9923;
+static const int enostr          = 9924;
+static const int enotconn        = 9925;
+static const int enotsup         = 9926;
+static const int ecanceled       = 9927;
+static const int einprogress     = 9928;
+static const int eopnotsupp      = 9929;
+static const int ewouldblock     = 9930;
+static const int eownerdead      = 9931;
+static const int eproto          = 9932;
+static const int eprotonosupport = 9933;
+static const int enotrecoverable = 9934;
+static const int etime           = 9935;
+static const int etxtbsy         = 9936;
+static const int etimedout       = 9938;
+static const int eloop           = 9939;
+static const int eoverflow       = 9940;
+static const int eprototype      = 9941;
+static const int enosys          = 9942;
+static const int einval          = 9943;
+static const int erange          = 9944;
+static const int eilseq          = 9945;
+static const int e2big           = 9946;
+static const int edom            = 9947;
+static const int efault          = 9948;
+static const int ebadf           = 9949;
+static const int epipe           = 9950;
+static const int exdev           = 9951;
+static const int ebusy           = 9952;
+static const int enotempty       = 9953;
+static const int enoexec         = 9954;
+static const int eexist          = 9955;
+static const int efbig           = 9956;
+static const int enametoolong    = 9957;
+static const int enotty          = 9958;
+static const int eintr           = 9959;
+static const int espipe          = 9960;
+static const int eio             = 9961;
+static const int eisdir          = 9962;
+static const int echild          = 9963;
+static const int enolck          = 9964;
+static const int enospc          = 9965;
+static const int enxio           = 9966;
+static const int enodev          = 9967;
+static const int enoent          = 9968;
+static const int esrch           = 9969;
+static const int enotdir         = 9970;
+static const int enomem          = 9971;
+static const int eperm           = 9972;
+static const int eacces          = 9973;
+static const int erofs           = 9974;
+static const int edeadlk         = 9975;
+static const int eagain          = 9976;
+static const int enfile          = 9977;
+static const int emfile          = 9978;
+static const int emlink          = 9979;
+
+} // end detail
+
+} // end system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_category.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_category.inl
new file mode 100644
index 0000000000000000000000000000000000000000..45fd15a3fd5331eee48ae69664c9a370fb26deae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_category.inl
@@ -0,0 +1,237 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/system/error_code.h>
+#include <thrust/system/detail/errno.h>
+#include <thrust/functional.h>
+#include <cstring>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+error_category
+  ::~error_category(void)
+{
+  ;
+} // end error_category::~error_category()
+
+
+error_condition error_category
+  ::default_error_condition(int ev) const
+{
+  return error_condition(ev, *this);
+} // end error_category::default_error_condition()
+
+
+bool error_category
+  ::equivalent(int code, const error_condition &condition) const
+{
+  return default_error_condition(code) == condition;
+} // end error_condition::equivalent()
+
+
+bool error_category
+  ::equivalent(const error_code &code, int condition) const
+{
+  bool result = (this->operator==(code.category())) && (code.value() == condition);
+  return result;
+} // end error_code::equivalent()
+
+
+bool error_category
+  ::operator==(const error_category &rhs) const
+{
+  return this == &rhs;
+} // end error_category::operator==()
+
+
+bool error_category
+  ::operator!=(const error_category &rhs) const
+{
+  return !this->operator==(rhs);
+} // end error_category::operator!=()
+
+
+bool error_category
+  ::operator<(const error_category &rhs) const
+{
+  return thrust::less<const error_category*>()(this,&rhs);
+} // end error_category::operator<()
+
+
+namespace detail
+{
+
+
+class generic_error_category
+  : public error_category
+{
+  public:
+    inline generic_error_category(void) {}
+
+    inline virtual const char *name(void) const
+    {
+      return "generic";
+    }
+
+    inline virtual std::string message(int ev) const
+    {
+      static const std::string unknown_err("Unknown error");
+
+      // XXX strerror is not thread-safe:
+      //     prefer strerror_r (which is not provided on windows)
+      THRUST_DISABLE_MSVC_WARNING_BEGIN(4996)
+      const char *c_str = std::strerror(ev);
+      THRUST_DISABLE_MSVC_WARNING_END(4996)
+      return c_str ? std::string(c_str) : unknown_err;
+    }
+}; // end generic_category_result
+
+
+class system_error_category
+  : public error_category
+{
+  public:
+    inline system_error_category(void) {}
+
+    inline virtual const char *name(void) const
+    {
+      return "system";
+    }
+
+    inline virtual std::string message(int ev) const
+    {
+      return generic_category().message(ev);
+    }
+
+    inline virtual error_condition default_error_condition(int ev) const
+    {
+      using namespace errc;
+
+      switch(ev)
+      {
+        case eafnosupport:    return make_error_condition(address_family_not_supported);
+        case eaddrinuse:      return make_error_condition(address_in_use);
+        case eaddrnotavail:   return make_error_condition(address_not_available);
+        case eisconn:         return make_error_condition(already_connected);
+        case e2big:           return make_error_condition(argument_list_too_long);
+        case edom:            return make_error_condition(argument_out_of_domain);
+        case efault:          return make_error_condition(bad_address);
+        case ebadf:           return make_error_condition(bad_file_descriptor);
+        case ebadmsg:         return make_error_condition(bad_message);
+        case epipe:           return make_error_condition(broken_pipe);
+        case econnaborted:    return make_error_condition(connection_aborted);
+        case ealready:        return make_error_condition(connection_already_in_progress);
+        case econnrefused:    return make_error_condition(connection_refused);
+        case econnreset:      return make_error_condition(connection_reset);
+        case exdev:           return make_error_condition(cross_device_link);
+        case edestaddrreq:    return make_error_condition(destination_address_required);
+        case ebusy:           return make_error_condition(device_or_resource_busy);
+        case enotempty:       return make_error_condition(directory_not_empty);
+        case enoexec:         return make_error_condition(executable_format_error);
+        case eexist:          return make_error_condition(file_exists);
+        case efbig:           return make_error_condition(file_too_large);
+        case enametoolong:    return make_error_condition(filename_too_long);
+        case enosys:          return make_error_condition(function_not_supported);
+        case ehostunreach:    return make_error_condition(host_unreachable);
+        case eidrm:           return make_error_condition(identifier_removed);
+        case eilseq:          return make_error_condition(illegal_byte_sequence);
+        case enotty:          return make_error_condition(inappropriate_io_control_operation);
+        case eintr:           return make_error_condition(interrupted);
+        case einval:          return make_error_condition(invalid_argument);
+        case espipe:          return make_error_condition(invalid_seek);
+        case eio:             return make_error_condition(io_error);
+        case eisdir:          return make_error_condition(is_a_directory);
+        case emsgsize:        return make_error_condition(message_size);
+        case enetdown:        return make_error_condition(network_down);
+        case enetreset:       return make_error_condition(network_reset);
+        case enetunreach:     return make_error_condition(network_unreachable);
+        case enobufs:         return make_error_condition(no_buffer_space);
+        case echild:          return make_error_condition(no_child_process);
+        case enolink:         return make_error_condition(no_link);
+        case enolck:          return make_error_condition(no_lock_available);
+        case enodata:         return make_error_condition(no_message_available);
+        case enomsg:          return make_error_condition(no_message);
+        case enoprotoopt:     return make_error_condition(no_protocol_option);
+        case enospc:          return make_error_condition(no_space_on_device);
+        case enosr:           return make_error_condition(no_stream_resources);
+        case enxio:           return make_error_condition(no_such_device_or_address);
+        case enodev:          return make_error_condition(no_such_device);
+        case enoent:          return make_error_condition(no_such_file_or_directory);
+        case esrch:           return make_error_condition(no_such_process);
+        case enotdir:         return make_error_condition(not_a_directory);
+        case enotsock:        return make_error_condition(not_a_socket);
+        case enostr:          return make_error_condition(not_a_stream);
+        case enotconn:        return make_error_condition(not_connected);
+        case enomem:          return make_error_condition(not_enough_memory);
+        case enotsup:         return make_error_condition(not_supported);
+        case ecanceled:       return make_error_condition(operation_canceled);
+        case einprogress:     return make_error_condition(operation_in_progress);
+        case eperm:           return make_error_condition(operation_not_permitted);
+        case eopnotsupp:      return make_error_condition(operation_not_supported);
+        case ewouldblock:     return make_error_condition(operation_would_block);
+        case eownerdead:      return make_error_condition(owner_dead);
+        case eacces:          return make_error_condition(permission_denied);
+        case eproto:          return make_error_condition(protocol_error);
+        case eprotonosupport: return make_error_condition(protocol_not_supported);
+        case erofs:           return make_error_condition(read_only_file_system);
+        case edeadlk:         return make_error_condition(resource_deadlock_would_occur);
+        case eagain:          return make_error_condition(resource_unavailable_try_again);
+        case erange:          return make_error_condition(result_out_of_range);
+        case enotrecoverable: return make_error_condition(state_not_recoverable);
+        case etime:           return make_error_condition(stream_timeout);
+        case etxtbsy:         return make_error_condition(text_file_busy);
+        case etimedout:       return make_error_condition(timed_out);
+        case enfile:          return make_error_condition(too_many_files_open_in_system);
+        case emfile:          return make_error_condition(too_many_files_open);
+        case emlink:          return make_error_condition(too_many_links);
+        case eloop:           return make_error_condition(too_many_symbolic_link_levels);
+        case eoverflow:       return make_error_condition(value_too_large);
+        case eprototype:      return make_error_condition(wrong_protocol_type);
+        default:              return error_condition(ev,system_category());
+      }
+    }
+}; // end system_category_result
+
+
+} // end detail
+
+
+const error_category &generic_category(void)
+{
+  static const detail::generic_error_category result;
+  return result;
+}
+
+
+const error_category &system_category(void)
+{
+  static const detail::system_error_category result;
+  return result;
+}
+
+
+} // end system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_code.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_code.inl
new file mode 100644
index 0000000000000000000000000000000000000000..2b819c0485e97b2edb49d56cfe06c59be03e1b04
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_code.inl
@@ -0,0 +1,198 @@
+/*
+ *  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>
+
+#include <thrust/system/error_code.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+error_code
+  ::error_code(void)
+    :m_val(0),m_cat(&system_category())
+{
+  ;
+} // end error_code::error_code()
+
+
+error_code
+  ::error_code(int val, const error_category &cat)
+    :m_val(val),m_cat(&cat)
+{
+  ;
+} // end error_code::error_code()
+
+
+template <typename ErrorCodeEnum>
+  error_code
+    ::error_code(ErrorCodeEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                 , typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type *
+#endif // THRUST_HOST_COMPILER_MSVC
+                )
+{
+  *this = make_error_code(e);
+} // end error_code::error_code()
+
+
+void error_code
+  ::assign(int val, const error_category &cat)
+{
+  m_val = val;
+  m_cat = &cat;
+} // end error_code::assign()
+
+
+template <typename ErrorCodeEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+  typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
+#else
+  error_code &
+#endif // THRUST_HOST_COMPILER_MSVC
+    error_code
+      ::operator=(ErrorCodeEnum e)
+{
+  *this = make_error_code(e);
+  return *this;
+} // end error_code::operator=()
+
+
+void error_code
+  ::clear(void)
+{
+  m_val = 0;
+  m_cat = &system_category();
+} // end error_code::clear()
+
+
+int error_code
+  ::value(void) const
+{
+  return m_val;
+} // end error_code::value()
+
+
+const error_category &error_code
+  ::category(void) const
+{
+  return *m_cat;
+} // end error_code::category()
+
+
+error_condition error_code
+  ::default_error_condition(void) const
+{
+  return category().default_error_condition(value());
+} // end error_code::default_error_condition()
+
+
+std::string error_code
+  ::message(void) const
+{
+  return category().message(value());
+} // end error_code::message()
+
+
+error_code
+  ::operator bool (void) const
+{
+  return value() != 0;
+} // end error_code::operator bool ()
+
+
+error_code make_error_code(errc::errc_t e)
+{
+  return error_code(static_cast<int>(e), generic_category());
+} // end make_error_code()
+
+
+bool operator<(const error_code &lhs, const error_code &rhs)
+{
+  bool result = lhs.category().operator<(rhs.category());
+  result = result || lhs.category().operator==(rhs.category());
+  result = result || lhs.value() < rhs.value();
+  return result;
+} // end operator==()
+
+
+template<typename charT, typename traits>
+  std::basic_ostream<charT,traits>&
+    operator<<(std::basic_ostream<charT,traits> &os, const error_code &ec)
+{
+  return os << ec.category().name() << ':' << ec.value();
+} // end operator<<()
+
+
+bool operator==(const error_code &lhs, const error_code &rhs)
+{
+  return lhs.category().operator==(rhs.category()) && lhs.value() == rhs.value();
+} // end operator==()
+
+
+bool operator==(const error_code &lhs, const error_condition &rhs)
+{
+  return lhs.category().equivalent(lhs.value(), rhs) || rhs.category().equivalent(lhs,rhs.value());
+} // end operator==()
+
+
+bool operator==(const error_condition &lhs, const error_code &rhs)
+{
+  return rhs.category().equivalent(lhs.value(), lhs) || lhs.category().equivalent(rhs, lhs.value());
+} // end operator==()
+
+
+bool operator==(const error_condition &lhs, const error_condition &rhs)
+{
+  return lhs.category().operator==(rhs.category()) && lhs.value() == rhs.value();
+} // end operator==()
+
+
+bool operator!=(const error_code &lhs, const error_code &rhs)
+{
+  return !(lhs == rhs);
+} // end operator!=()
+
+
+bool operator!=(const error_code &lhs, const error_condition &rhs)
+{
+  return !(lhs == rhs);
+} // end operator!=()
+
+
+bool operator!=(const error_condition &lhs, const error_code &rhs)
+{
+  return !(lhs == rhs);
+} // end operator!=()
+
+
+bool operator!=(const error_condition &lhs, const error_condition &rhs)
+{
+  return !(lhs == rhs);
+} // end operator!=()
+
+
+} // end system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_condition.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_condition.inl
new file mode 100644
index 0000000000000000000000000000000000000000..0daf1f2938b98c549c4498d9b606ea27be3472eb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/error_condition.inl
@@ -0,0 +1,134 @@
+/*
+ *  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>
+
+#include <thrust/system/detail/error_condition.inl>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+error_condition
+  ::error_condition(void)
+    :m_val(0),m_cat(&generic_category())
+{
+  ;
+} // end error_condition::error_condition()
+
+
+error_condition
+  ::error_condition(int val, const error_category &cat)
+    :m_val(val),m_cat(&cat)
+{
+  ;
+} // end error_condition::error_condition()
+
+
+template<typename ErrorConditionEnum>
+  error_condition
+    ::error_condition(ErrorConditionEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                      , typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type *
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     )
+{
+  *this = make_error_condition(e);
+} // end error_condition::error_condition()
+
+
+void error_condition
+  ::assign(int val, const error_category &cat)
+{
+  m_val = val;
+  m_cat = &cat;
+} // end error_category::assign()
+
+
+template<typename ErrorConditionEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+  typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
+#else
+  error_condition &
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+    error_condition
+      ::operator=(ErrorConditionEnum e)
+{
+  *this = make_error_condition(e);
+  return *this;
+} // end error_condition::operator=()
+
+
+void error_condition
+  ::clear(void)
+{
+  m_val = 0;
+  m_cat = &generic_category();
+} // end error_condition::clear()
+
+
+int error_condition
+  ::value(void) const
+{
+  return m_val;
+} // end error_condition::value()
+
+
+const error_category &error_condition
+  ::category(void) const
+{
+  return *m_cat;
+} // end error_condition::category()
+
+
+std::string error_condition
+  ::message(void) const
+{
+  return category().message(value());
+} // end error_condition::message()
+
+
+error_condition
+  ::operator bool (void) const
+{
+  return value() != 0;
+} // end error_condition::operator bool ()
+
+
+error_condition make_error_condition(errc::errc_t e)
+{
+  return error_condition(static_cast<int>(e), generic_category());
+} // end make_error_condition()
+
+
+bool operator<(const error_condition &lhs,
+               const error_condition &rhs)
+{
+  return lhs.category().operator<(rhs.category()) || (lhs.category().operator==(rhs.category()) && (lhs.value() < rhs.value()));
+} // end operator<()
+
+
+} // end system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/system_error.inl b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/system_error.inl
new file mode 100644
index 0000000000000000000000000000000000000000..075fe88e463977e89a2f127e6afc00c9c81389a3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/system_error.inl
@@ -0,0 +1,112 @@
+/*
+ *  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>
+
+#include <thrust/system/system_error.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+
+system_error
+  ::system_error(error_code ec, const std::string &what_arg)
+    : std::runtime_error(what_arg), m_error_code(ec)
+{
+
+} // end system_error::system_error()
+
+
+system_error
+  ::system_error(error_code ec, const char *what_arg)
+    : std::runtime_error(what_arg), m_error_code(ec)
+{
+  ;
+} // end system_error::system_error()
+
+
+system_error
+  ::system_error(error_code ec)
+    : std::runtime_error(""), m_error_code(ec)
+{
+  ;
+} // end system_error::system_error()
+
+
+system_error
+  ::system_error(int ev, const error_category &ecat, const std::string &what_arg)
+    : std::runtime_error(what_arg), m_error_code(ev,ecat)
+{
+  ;
+} // end system_error::system_error()
+
+
+system_error
+  ::system_error(int ev, const error_category &ecat, const char *what_arg)
+    : std::runtime_error(what_arg), m_error_code(ev,ecat)
+{
+  ;
+} // end system_error::system_error()
+
+
+system_error
+  ::system_error(int ev, const error_category &ecat)
+    : std::runtime_error(""), m_error_code(ev,ecat)
+{
+  ;
+} // end system_error::system_error()
+
+
+const error_code &system_error
+  ::code(void) const noexcept
+{
+  return m_error_code;
+} // end system_error::code()
+
+
+const char *system_error
+  ::what(void) const noexcept
+{
+  if(m_what.empty())
+  {
+    try
+    {
+      m_what = this->std::runtime_error::what();
+      if(m_error_code)
+      {
+        if(!m_what.empty()) m_what += ": ";
+        m_what += m_error_code.message();
+      }
+    }
+    catch(...)
+    {
+      return std::runtime_error::what();
+    }
+  }
+
+  return m_what.c_str();
+} // end system_error::what()
+
+
+} // end system
+
+THRUST_NAMESPACE_END
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/error_code.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/error_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..d460a315b1d50d1ecdff26f4c8dab3aac6b4f6f6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/error_code.h
@@ -0,0 +1,522 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file error_code.h
+ *  \brief An object used to hold error values, such as those originating from the
+ *         operating system or other low-level application program interfaces.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/system/detail/errno.h>
+#include <iostream>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+
+/*! \addtogroup system_diagnostics
+ *  \{
+ */
+
+class error_condition;
+class error_code;
+
+/*! A metafunction returning whether or not the parameter is an \p error_code enum.
+ */
+template<typename T> struct is_error_code_enum : public thrust::detail::false_type {};
+
+/*! A metafunction returning whether or not the parameter is an \p error_condition enum.
+ */
+template<typename T> struct is_error_condition_enum : public thrust::detail::false_type {};
+
+
+// XXX N3092 prefers enum class errc { ... }
+namespace errc
+{
+
+/*! An enum containing common error codes.
+ */
+enum errc_t
+{
+  address_family_not_supported       = detail::eafnosupport,
+  address_in_use                     = detail::eaddrinuse,
+  address_not_available              = detail::eaddrnotavail,
+  already_connected                  = detail::eisconn,
+  argument_list_too_long             = detail::e2big,
+  argument_out_of_domain             = detail::edom,
+  bad_address                        = detail::efault,
+  bad_file_descriptor                = detail::ebadf,
+  bad_message                        = detail::ebadmsg,
+  broken_pipe                        = detail::epipe,
+  connection_aborted                 = detail::econnaborted,
+  connection_already_in_progress     = detail::ealready,
+  connection_refused                 = detail::econnrefused,
+  connection_reset                   = detail::econnreset,
+  cross_device_link                  = detail::exdev,
+  destination_address_required       = detail::edestaddrreq,
+  device_or_resource_busy            = detail::ebusy,
+  directory_not_empty                = detail::enotempty,
+  executable_format_error            = detail::enoexec,
+  file_exists                        = detail::eexist,
+  file_too_large                     = detail::efbig,
+  filename_too_long                  = detail::enametoolong,
+  function_not_supported             = detail::enosys,
+  host_unreachable                   = detail::ehostunreach,
+  identifier_removed                 = detail::eidrm,
+  illegal_byte_sequence              = detail::eilseq,
+  inappropriate_io_control_operation = detail::enotty,
+  interrupted                        = detail::eintr,
+  invalid_argument                   = detail::einval,
+  invalid_seek                       = detail::espipe,
+  io_error                           = detail::eio,
+  is_a_directory                     = detail::eisdir,
+  message_size                       = detail::emsgsize,
+  network_down                       = detail::enetdown,
+  network_reset                      = detail::enetreset,
+  network_unreachable                = detail::enetunreach,
+  no_buffer_space                    = detail::enobufs,
+  no_child_process                   = detail::echild,
+  no_link                            = detail::enolink,
+  no_lock_available                  = detail::enolck,
+  no_message_available               = detail::enodata,
+  no_message                         = detail::enomsg,
+  no_protocol_option                 = detail::enoprotoopt,
+  no_space_on_device                 = detail::enospc,
+  no_stream_resources                = detail::enosr,
+  no_such_device_or_address          = detail::enxio,
+  no_such_device                     = detail::enodev,
+  no_such_file_or_directory          = detail::enoent,
+  no_such_process                    = detail::esrch,
+  not_a_directory                    = detail::enotdir,
+  not_a_socket                       = detail::enotsock,
+  not_a_stream                       = detail::enostr,
+  not_connected                      = detail::enotconn,
+  not_enough_memory                  = detail::enomem,
+  not_supported                      = detail::enotsup,
+  operation_canceled                 = detail::ecanceled,
+  operation_in_progress              = detail::einprogress,
+  operation_not_permitted            = detail::eperm,
+  operation_not_supported            = detail::eopnotsupp,
+  operation_would_block              = detail::ewouldblock,
+  owner_dead                         = detail::eownerdead,
+  permission_denied                  = detail::eacces,
+  protocol_error                     = detail::eproto,
+  protocol_not_supported             = detail::eprotonosupport,
+  read_only_file_system              = detail::erofs,
+  resource_deadlock_would_occur      = detail::edeadlk,
+  resource_unavailable_try_again     = detail::eagain,
+  result_out_of_range                = detail::erange,
+  state_not_recoverable              = detail::enotrecoverable,
+  stream_timeout                     = detail::etime,
+  text_file_busy                     = detail::etxtbsy,
+  timed_out                          = detail::etimedout,
+  too_many_files_open_in_system      = detail::enfile,
+  too_many_files_open                = detail::emfile,
+  too_many_links                     = detail::emlink,
+  too_many_symbolic_link_levels      = detail::eloop,
+  value_too_large                    = detail::eoverflow,
+  wrong_protocol_type                = detail::eprototype
+}; // end errc_t
+
+} // end namespace errc
+
+
+/*! Specialization of \p is_error_condition_enum for \p errc::errc_t
+ */
+template<> struct is_error_condition_enum<errc::errc_t> : public thrust::detail::true_type {};
+
+
+// [19.5.1.1] class error_category
+
+/*! \brief The class \p error_category serves as a base class for types used to identify the
+ *         source and encoding of a particular category of error code. Classes may be derived
+ *         from \p error_category to support categories of errors in addition to those defined
+ *         in the C++ International Standard.
+ */
+class error_category
+{
+  public:
+    /*! Destructor does nothing.
+     */
+    inline virtual ~error_category(void);
+
+    // XXX enable upon c++0x
+    // error_category(const error_category &) = delete;
+    // error_category &operator=(const error_category &) = delete;
+
+    /*! \return A string naming the error category.
+     */
+    inline virtual const char *name(void) const = 0;
+
+    /*! \return \p error_condition(ev, *this).
+     */
+    inline virtual error_condition default_error_condition(int ev) const;
+
+    /*! \return <tt>default_error_condition(code) == condition</tt>
+     */
+    inline virtual bool equivalent(int code, const error_condition &condition) const;
+
+    /*! \return <tt>*this == code.category() && code.value() == condition</tt>
+     */
+    inline virtual bool equivalent(const error_code &code, int condition) const;
+
+    /*! \return A string that describes the error condition denoted by \p ev.
+     */
+    virtual std::string message(int ev) const = 0;
+
+    /*! \return <tt>*this == &rhs</tt>
+     */
+    inline bool operator==(const error_category &rhs) const;
+
+    /*! \return <tt>!(*this == rhs)</tt>
+     */
+    inline bool operator!=(const error_category &rhs) const;
+
+    /*! \return <tt>less<const error_category*>()(this, &rhs)</tt>
+     *  \note \c less provides a total ordering for pointers.
+     */
+    inline bool operator<(const error_category &rhs) const;
+}; // end error_category
+
+
+// [19.5.1.5] error_category objects
+
+
+/*! \return A reference to an object of a type derived from class \p error_category.
+ *  \note The object's \p default_error_condition and \p equivalent virtual functions
+ *        shall behave as specified for the class \p error_category. The object's
+ *        \p name virtual function shall return a pointer to the string <tt>"generic"</tt>.
+ */
+inline const error_category &generic_category(void);
+
+
+/*! \return A reference to an object of a type derived from class \p error_category.
+ *  \note The object's \p equivalent virtual functions shall behave as specified for
+ *        class \p error_category. The object's \p name virtual function shall return
+ *        a pointer to the string <tt>"system"</tt>. The object's \p default_error_condition
+ *        virtual function shall behave as follows:
+ *
+ *        If the argument <tt>ev</tt> corresponds to a POSIX <tt>errno</tt> value
+ *        \c posv, the function shall return <tt>error_condition(ev,generic_category())</tt>.
+ *        Otherwise, the function shall return <tt>error_condition(ev,system_category())</tt>.
+ *        What constitutes correspondence for any given operating system is unspecified.
+ */
+inline const error_category &system_category(void);
+
+
+// [19.5.2] Class error_code
+
+
+/*! \brief The class \p error_code describes an object used to hold error code values, such as
+ *         those originating from the operating system or other low-level application program
+ *         interfaces.
+ */
+class error_code
+{
+  public:
+    // [19.5.2.2] constructors:
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>value() == 0</tt> and <tt>category() == &system_category()</tt>.
+     */
+    inline error_code(void);
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>value() == val</tt> and <tt>category() == &cat</tt>.
+     */
+    inline error_code(int val, const error_category &cat);
+
+    /*! Effects: Constructs an object of type \p error_code.
+     *  \post <tt>*this == make_error_code(e)</tt>.
+     */
+    template <typename ErrorCodeEnum>
+      error_code(ErrorCodeEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        , typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0
+#endif // THRUST_HOST_COMPILER_MSVC
+        );
+
+    // [19.5.2.3] modifiers:
+
+    /*! \post <tt>value() == val</tt> and <tt>category() == &cat</tt>.
+     */
+    inline void assign(int val, const error_category &cat);
+
+    /*! \post <tt>*this == make_error_code(e)</tt>.
+     */
+    template <typename ErrorCodeEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+      typename thrust::detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
+#else
+      error_code &
+#endif // THRUST_HOST_COMPILER_MSVC
+        operator=(ErrorCodeEnum e);
+
+    /*! \post <tt>value() == 0</tt> and <tt>category() == system_category()</tt>.
+     */
+    inline void clear(void);
+
+    // [19.5.2.4] observers:
+
+    /*! \return An integral value of this \p error_code object.
+     */
+    inline int value(void) const;
+
+    /*! \return An \p error_category describing the category of this \p error_code object.
+     */
+    inline const error_category &category(void) const;
+
+    /*! \return <tt>category().default_error_condition()</tt>.
+     */
+    inline error_condition default_error_condition(void) const;
+
+    /*! \return <tt>category().message(value())</tt>.
+     */
+    inline std::string message(void) const;
+
+    // XXX replace the below upon c++0x
+    // inline explicit operator bool (void) const;
+
+    /*! \return <tt>value() != 0</tt>.
+     */
+    inline operator bool (void) const;
+
+    /*! \cond
+     */
+  private:
+    int m_val;
+    const error_category *m_cat;
+    /*! \endcond
+     */
+}; // end error_code
+
+
+// [19.5.2.5] Class error_code non-member functions
+
+
+// XXX replace errc::errc_t with errc upon c++0x
+/*! \return <tt>error_code(static_cast<int>(e), generic_category())</tt>
+ */
+inline error_code make_error_code(errc::errc_t e);
+
+
+/*! \return <tt>lhs.category() < rhs.category() || lhs.category() == rhs.category() && lhs.value() < rhs.value()</tt>.
+ */
+inline bool operator<(const error_code &lhs, const error_code &rhs);
+
+
+/*! Effects: <tt>os << ec.category().name() << ':' << ec.value()</tt>.
+ */
+template <typename charT, typename traits>
+  std::basic_ostream<charT,traits>&
+    operator<<(std::basic_ostream<charT,traits>& os, const error_code &ec);
+
+
+// [19.5.3] class error_condition
+
+
+/*! \brief The class \p error_condition describes an object used to hold values identifying
+ *  error conditions.
+ *
+ *  \note \p error_condition values are portable abstractions, while \p error_code values
+ *        are implementation specific.
+ */
+class error_condition
+{
+  public:
+    // [19.5.3.2] constructors
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>value() == 0</tt>.
+     *  \post <tt>category() == generic_category()</tt>.
+     */
+    inline error_condition(void);
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>value() == val</tt>.
+     *  \post <tt>category() == cat</tt>.
+     */
+    inline error_condition(int val, const error_category &cat);
+
+    /*! Constructs an object of type \p error_condition.
+     *  \post <tt>*this == make_error_condition(e)</tt>.
+     *  \note This constructor shall not participate in overload resolution unless
+     *        <tt>is_error_condition_enum<ErrorConditionEnum>::value</tt> is <tt>true</tt>.
+     */
+    template<typename ErrorConditionEnum>
+      error_condition(ErrorConditionEnum e
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        , typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type * = 0
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+                     );
+
+    // [19.5.3.3] modifiers
+
+    /*! Assigns to this \p error_code object from an error value and an \p error_category.
+     *  \param val The new value to return from <tt>value()</tt>.
+     *  \param cat The new \p error_category to return from <tt>category()</tt>.
+     *  \post <tt>value() == val</tt>.
+     *  \post <tt>category() == cat</tt>.
+     */
+    inline void assign(int val, const error_category &cat);
+
+    /*! Assigns to this \p error_code object from an error condition enumeration.
+     *  \return *this
+     *  \post <tt>*this == make_error_condition(e)</tt>.
+     *  \note This operator shall not participate in overload resolution unless
+     *        <tt>is_error_condition_enum<ErrorConditionEnum>::value</tt> is <tt>true</tt>.
+     */
+    template<typename ErrorConditionEnum>
+// XXX WAR msvc's problem with enable_if
+#if THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+      typename thrust::detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
+#else
+      error_condition &
+#endif // THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
+        operator=(ErrorConditionEnum e);
+
+    /*! Clears this \p error_code object.
+     *  \post <tt>value == 0</tt>
+     *  \post <tt>category() == generic_category()</tt>.
+     */
+    inline void clear(void);
+
+    // [19.5.3.4] observers
+
+    /*! \return The value encoded by this \p error_condition.
+     */
+    inline int value(void) const;
+
+    /*! \return A <tt>const</tt> reference to the \p error_category encoded by this \p error_condition.
+     */
+    inline const error_category &category(void) const;
+
+    /*! \return <tt>category().message(value())</tt>.
+     */
+    inline std::string message(void) const;
+
+    // XXX replace below with this upon c++0x
+    //explicit operator bool (void) const;
+    
+    /*! \return <tt>value() != 0</tt>.
+     */
+    inline operator bool (void) const;
+
+    /*! \cond
+     */
+
+  private:
+    int m_val;
+    const error_category *m_cat;
+
+    /*! \endcond
+     */
+}; // end error_condition
+
+
+
+// [19.5.3.5] Class error_condition non-member functions
+
+// XXX replace errc::errc_t with errc upon c++0x
+/*! \return <tt>error_condition(static_cast<int>(e), generic_category())</tt>.
+ */
+inline error_condition make_error_condition(errc::errc_t e);
+
+
+/*! \return <tt>lhs.category() < rhs.category() || lhs.category() == rhs.category() && lhs.value() < rhs.value()</tt>.
+ */
+inline bool operator<(const error_condition &lhs, const error_condition &rhs);
+
+
+// [19.5.4] Comparison operators
+
+
+/*! \return <tt>lhs.category() == rhs.category() && lhs.value() == rhs.value()</tt>.
+ */
+inline bool operator==(const error_code &lhs, const error_code &rhs);
+
+
+/*! \return <tt>lhs.category().equivalent(lhs.value(), rhs) || rhs.category().equivalent(lhs,rhs.value())</tt>.
+ */
+inline bool operator==(const error_code &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>rhs.category().equivalent(lhs.value(), lhs) || lhs.category().equivalent(rhs, lhs.value())</tt>.
+ */
+inline bool operator==(const error_condition &lhs, const error_code &rhs);
+
+
+/*! \return <tt>lhs.category() == rhs.category() && lhs.value() == rhs.value()</tt>
+ */
+inline bool operator==(const error_condition &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_code &lhs, const error_code &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_code &lhs, const error_condition &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_condition &lhs, const error_code &rhs);
+
+
+/*! \return <tt>!(lhs == rhs)</tt>
+ */
+inline bool operator!=(const error_condition &lhs, const error_condition &rhs);
+
+/*! \} // end system_diagnostics
+ */
+
+
+} // end system
+
+
+// import names into thrust::
+using system::error_category;
+using system::error_code;
+using system::error_condition;
+using system::is_error_code_enum;
+using system::is_error_condition_enum;
+using system::make_error_code;
+using system::make_error_condition;
+
+// XXX replace with using system::errc upon c++0x
+namespace errc = system::errc;
+
+using system::generic_category;
+using system::system_category;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/error_category.inl>
+#include <thrust/system/detail/error_code.inl>
+#include <thrust/system/detail/error_condition.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/system_error.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/system_error.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb31a2da805e6a338c4a9e3e5d0a7a18655c83e3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/system_error.h
@@ -0,0 +1,178 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file system/system_error.h
+ *  \brief An exception object used to report error conditions that have an
+ *         associated error code
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <stdexcept>
+#include <string>
+
+#include <thrust/system/error_code.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace system
+{
+
+// [19.5.5] Class system_error
+
+// [19.5.5.1] Class system_error overview
+
+/*! \addtogroup system_diagnostics System Diagnostics
+ *  \ingroup system
+ *  \{
+ */
+
+/*! \brief The class \p system_error describes an exception object used to report error
+ *  conditions that have an associated \p error_code. Such error conditions typically
+ *  originate from the operating system or other low-level application program interfaces.
+ *
+ *  Thrust uses \p system_error to report the error codes returned from device backends
+ *  such as the CUDA runtime.
+ *
+ *  The following code listing demonstrates how to catch a \p system_error to recover
+ *  from an error.
+ *
+ *  \code
+ *
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/system.h>
+ *  #include <thrust/sort.h>
+ *
+ *  void terminate_gracefully(void)
+ *  {
+ *    // application-specific termination code here
+ *    ...
+ *  }
+ *
+ *  int main(void)
+ *  {
+ *    try
+ *    {
+ *      thrust::device_vector<float> vec;
+ *      thrust::sort(vec.begin(), vec.end());
+ *    }
+ *    catch(thrust::system_error e)
+ *    {
+ *      std::cerr << "Error inside sort: " << e.what() << std::endl;
+ *      terminate_gracefully();
+ *    }
+ *
+ *    return 0;
+ *  }
+ *
+ *  \endcode
+ *
+ *  \note If an error represents an out-of-memory condition, implementations are encouraged
+ *  to throw an exception object of type \p std::bad_alloc rather than \p system_error.
+ */
+class system_error
+  : public std::runtime_error
+{
+  public:
+    // [19.5.5.2] Class system_error members
+    
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == ec</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(error_code ec, const std::string &what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == ec</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(error_code ec, const char *what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ec The value returned by \p code().
+     *  \post <tt>code() == ec</tt>.
+     */
+    inline system_error(error_code ec);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat, const std::string &what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \param what_arg A string to include in the result returned by \p what().
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     *  \post <tt>std::string(what()).find(what_arg) != string::npos</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat, const char *what_arg);
+
+    /*! Constructs an object of class \p system_error.
+     *  \param ev The error value used to create an \p error_code.
+     *  \param ecat The \p error_category used to create an \p error_code.
+     *  \post <tt>code() == error_code(ev, ecat)</tt>.
+     */
+    inline system_error(int ev, const error_category &ecat);
+
+    /*! Destructor does not throw.
+     */
+    inline virtual ~system_error(void) noexcept {};
+    
+    /*! Returns an object encoding the error.
+     *  \return <tt>ec</tt> or <tt>error_code(ev, ecat)</tt>, from the
+     *          constructor, as appropriate.
+     */
+    inline const error_code &code(void) const noexcept;
+
+    /*! Returns a human-readable string indicating the nature of the error.
+     *  \return a string incorporating <tt>code().message()</tt> and the
+     *          arguments supplied in the constructor.
+     */
+    inline const char *what(void) const noexcept;
+
+    /*! \cond
+     */
+  private:
+    error_code          m_error_code;
+    mutable std::string m_what;
+
+    /*! \endcond
+     */
+}; // end system_error
+
+} // end system
+
+/*! \} // end system_diagnostics
+ */
+
+// import names into thrust::
+using system::system_error;
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/system_error.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system_error.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system_error.h
new file mode 100644
index 0000000000000000000000000000000000000000..6bf240e512342ada0226521f49dc07ca49d5a104
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system_error.h
@@ -0,0 +1,49 @@
+/*
+ *  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 thrust/system_error.h
+ *  \brief System diagnostics
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup system
+ *  \{
+ */
+
+/*! \namespace thrust::system
+ *  \brief \p thrust::system is the namespace which contains specific Thrust
+ *         backend systems. It also contains functionality for reporting error
+ *         conditions originating from the operating system or other low-level
+ *         application program interfaces such as the CUDA runtime. They are
+ *         provided in a separate namespace for import convenience but are
+ *         also aliased in the top-level \p thrust namespace for easy access.
+ */
+namespace system
+{
+} // end system
+
+/*! \} // end system
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/system/error_code.h>
+#include <thrust/system/system_error.h>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tabulate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tabulate.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cb7945508d44a1490bb7df3c373864019202800
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tabulate.h
@@ -0,0 +1,125 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file tabulate.h
+ *  \brief Fills a range with the tabulation of a function
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup transformations
+ *  \{
+ */
+
+
+/*! \p tabulate fills the range <tt>[first, last)</tt> with the value of a function applied to each
+ *     element's index.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, \p tabulate performs the assignment
+ *  <tt>*i = unary_op(i - first)</tt>.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range.
+ *  \param last The end of the range.
+ *  \param unary_op The unary operation to apply.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam UnaryOperation is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                         and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p tabulate to generate the first \c n non-positive integers
+ *  using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/tabulate.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::tabulate(thrust::host, A, A + 10, thrust::negate<int>());
+ *  // A is now {0, -1, -2, -3, -4, -5, -6, -7, -8, -9}
+ *  \endcode
+ *
+ *  \see thrust::fill
+ *  \see thrust::generate
+ *  \see thrust::sequence
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename UnaryOperation>
+__host__ __device__
+  void tabulate(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator first,
+                ForwardIterator last,
+                UnaryOperation unary_op);
+
+
+/*! \p tabulate fills the range <tt>[first, last)</tt> with the value of a function applied to each
+ *     element's index.
+ *
+ *  For each iterator \c i in the range <tt>[first, last)</tt>, \p tabulate performs the assignment
+ *  <tt>*i = unary_op(i - first)</tt>.
+ *
+ *  \param first The beginning of the range.
+ *  \param last The end of the range.
+ *  \param unary_op The unary operation to apply.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
+ *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
+ *  \tparam UnaryOperation is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                         and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  The following code snippet demonstrates how to use \p tabulate to generate the first \c n non-positive integers:
+ *
+ *  \code
+ *  #include <thrust/tabulate.h>
+ *  #include <thrust/functional.h>
+ *  ...
+ *  const int N = 10;
+ *  int A[N];
+ *  thrust::tabulate(A, A + 10, thrust::negate<int>());
+ *  // A is now {0, -1, -2, -3, -4, -5, -6, -7, -8, -9}
+ *  \endcode
+ *
+ *  \see thrust::fill
+ *  \see thrust::generate
+ *  \see thrust::sequence
+ */
+template<typename ForwardIterator, typename UnaryOperation>
+  void tabulate(ForwardIterator first,
+                ForwardIterator last,
+                UnaryOperation unary_op);
+
+
+/*! \} // end transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/tabulate.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d064c13b3e4dcf179f186f9d6e4237110065bb1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform.h
@@ -0,0 +1,721 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/transform.h
+ *  \brief Transforms input ranges using a function object
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup transformations
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! This version of \p transform applies a unary function to each element
+ *  of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence.  Specifically, for each iterator 
+ *  <tt>i</tt> in the range [\p first, \p last) the operation 
+ *  <tt>op(*i)</tt> is performed and the result is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  [\p result, \p result + (\p last - \p first) ).  The input and
+ *  output sequences may coincide, resulting in an in-place transformation.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The transformation operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                              and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform to negate a range in-place
+ *  using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::negate<int> op;
+ *
+ *  thrust::transform(thrust::host, data, data + 10, data, op); // in-place transformation
+ *
+ *  // data is now {5, 0, -2, 3, -2, -4, 0, 1, -2, -8};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/transform
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction>
+__host__ __device__
+  OutputIterator transform(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first, InputIterator last,
+                           OutputIterator result,
+                           UnaryFunction op);
+
+	
+/*! This version of \p transform applies a unary function to each element
+ *  of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence.  Specifically, for each iterator 
+ *  <tt>i</tt> in the range [\p first, \p last) the operation 
+ *  <tt>op(*i)</tt> is performed and the result is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  [\p result, \p result + (\p last - \p first) ).  The input and
+ *  output sequences may coincide, resulting in an in-place transformation.
+ *    
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                              and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10] = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ * 
+ *  thrust::negate<int> op;
+ *
+ *  thrust::transform(data, data + 10, data, op); // in-place transformation
+ *
+ *  // data is now {5, 0, -2, 3, -2, -4, 0, 1, -2, -8};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/transform
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction>
+  OutputIterator transform(InputIterator first, InputIterator last,
+                           OutputIterator result,
+                           UnaryFunction op);
+
+
+/*! This version of \p transform applies a binary function to each pair
+ *  of elements from two input sequences and stores the result in the
+ *  corresponding position in an output sequence.  Specifically, for
+ *  each iterator <tt>i</tt> in the range [\p first1, \p last1) and 
+ *  <tt>j = first + (i - first1)</tt> in the range [\p first2, \p last2)
+ *  the operation <tt>op(*i,*j)</tt> is performed and the result is 
+ *  assigned to <tt>*o</tt>,  where <tt>o</tt> is the corresponding
+ *  output iterator in the range [\p result, \p result + (\p last - \p first) ).
+ *  The input and output sequences may coincide, resulting in an 
+ *  in-place transformation.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input sequence.
+ *  \param last1 The end of the first input sequence.
+ *  \param first2 The beginning of the second input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator1's \c value_type is convertible to \c BinaryFunction's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator2's \c value_type is convertible to \c BinaryFunction's \c second_argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c BinaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p first2 may equal \p result, but the range <tt>[first2, first2 + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform to compute the sum of two
+ *  ranges using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int input1[6] = {-5,  0,  2,  3,  2,  4};
+ *  int input2[6] = { 3,  6, -2,  1,  2,  3};
+ *  int output[6];
+ * 
+ *  thrust::plus<int> op;
+ *
+ *  thrust::transform(thrust::host, input1, input1 + 6, input2, output, op);
+ *
+ *  // output is now {-2,  6,  0,  4,  4,  7};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/transform
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryFunction>
+__host__ __device__
+  OutputIterator transform(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1 first1, InputIterator1 last1,
+                           InputIterator2 first2,
+                           OutputIterator result,
+                           BinaryFunction op);
+
+
+/*! This version of \p transform applies a binary function to each pair
+ *  of elements from two input sequences and stores the result in the
+ *  corresponding position in an output sequence.  Specifically, for
+ *  each iterator <tt>i</tt> in the range [\p first1, \p last1) and 
+ *  <tt>j = first + (i - first1)</tt> in the range [\p first2, \p last2)
+ *  the operation <tt>op(*i,*j)</tt> is performed and the result is 
+ *  assigned to <tt>*o</tt>,  where <tt>o</tt> is the corresponding
+ *  output iterator in the range [\p result, \p result + (\p last - \p first) ).
+ *  The input and output sequences may coincide, resulting in an 
+ *  in-place transformation.
+ *    
+ *  \param first1 The beginning of the first input sequence.
+ *  \param last1 The end of the first input sequence.
+ *  \param first2 The beginning of the second input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator1's \c value_type is convertible to \c BinaryFunction's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                        and \c InputIterator2's \c value_type is convertible to \c BinaryFunction's \c second_argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c BinaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first1 may equal \p result, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p first2 may equal \p result, but the range <tt>[first2, first2 + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int input1[6] = {-5,  0,  2,  3,  2,  4};
+ *  int input2[6] = { 3,  6, -2,  1,  2,  3};
+ *  int output[6];
+ * 
+ *  thrust::plus<int> op;
+ *
+ *  thrust::transform(input1, input1 + 6, input2, output, op);
+ *
+ *  // output is now {-2,  6,  0,  4,  4,  7};
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/transform
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename BinaryFunction>
+  OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
+                           InputIterator2 first2,
+                           OutputIterator result,
+                           BinaryFunction op);
+
+
+/*! This version of \p transform_if conditionally applies a unary function
+ *  to each element of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in the input sequence
+ *  satifies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first, last)</tt> the
+ *  predicate <tt>pred(*i)</tt> is evaluated. If this predicate
+ *  evaluates to \c true, the result of <tt>op(*i)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last - first) )</tt>. Otherwise, <tt>op(*i)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \c InputIterator's \c value_type is convertible to \c Predicate's \c argument_type,
+ *                        and \c InputIterator's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                        and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if to negate the odd-valued
+ *  elements of a range using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10]    = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ *
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x % 2;
+ *    }
+ *  };
+ * 
+ *  thrust::negate<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  // negate odd elements
+ *  thrust::transform_if(thrust::host, data, data + 10, data, op, is_odd()); // in-place transformation
+ *
+ *  // data is now {5, 0, 2, 3, 2, 4, 0, 1, 2, 8};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator first, InputIterator last,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred);
+
+
+/*! This version of \p transform_if conditionally applies a unary function
+ *  to each element of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in the input sequence
+ *  satifies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first, last)</tt> the
+ *  predicate <tt>pred(*i)</tt> is evaluated. If this predicate
+ *  evaluates to \c true, the result of <tt>op(*i)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last - first) )</tt>. Otherwise, <tt>op(*i)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *    
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \c InputIterator's \c value_type is convertible to \c Predicate's \c argument_type,
+ *                        and \c InputIterator's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                        and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10]    = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ *
+ *  struct is_odd
+ *  {
+ *    __host__ __device__
+ *    bool operator()(int x)
+ *    {
+ *      return x % 2;
+ *    }
+ *  };
+ * 
+ *  thrust::negate<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  // negate odd elements
+ *  thrust::transform_if(data, data + 10, data, op, is_odd()); // in-place transformation
+ *
+ *  // data is now {5, 0, 2, 3, 2, 4, 0, 1, 2, 8};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename InputIterator,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator first, InputIterator last,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred);
+
+
+/*! This version of \p transform_if conditionally applies a unary function
+ *  to each element of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in a stencil sequence
+ *  satisfies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first, last)</tt> the
+ *  predicate <tt>pred(*s)</tt> is evaluated, where <tt>s</tt> is the corresponding input
+ *  iterator in the range <tt>[stencil, stencil + (last - first) )</tt>. If this predicate
+ *  evaluates to \c true, the result of <tt>op(*i)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last - first) )</tt>. Otherwise, <tt>op(*i)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator1's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c Predicate's \c argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                        and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *  \pre \p stencil may equal \p result, but the range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[10]    = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ *  int stencil[10] = { 1, 0, 1,  0, 1, 0, 1,  0, 1, 0};
+ * 
+ *  thrust::negate<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  thrust::transform_if(thrust::host, data, data + 10, stencil, data, op, identity); // in-place transformation
+ *
+ *  // data is now {5, 0, -2, -3, -2,  4, 0, -1, -2,  8};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator1 first, InputIterator1 last,
+                               InputIterator2 stencil,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred);
+
+
+/*! This version of \p transform_if conditionally applies a unary function
+ *  to each element of an input sequence and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in a stencil sequence
+ *  satisfies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first, last)</tt> the
+ *  predicate <tt>pred(*s)</tt> is evaluated, where <tt>s</tt> is the corresponding input
+ *  iterator in the range <tt>[stencil, stencil + (last - first) )</tt>. If this predicate
+ *  evaluates to \c true, the result of <tt>op(*i)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last - first) )</tt>. Otherwise, <tt>op(*i)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *    
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param op The tranformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator1's \c value_type is convertible to \c UnaryFunction's \c argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c Predicate's \c argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                        and \c UnaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *  \pre \p stencil may equal \p result, but the range <tt>[stencil, stencil + (last - first))</tt> shall not overlap the range <tt>[result, result + (last - first))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int data[10]    = {-5, 0, 2, -3, 2, 4, 0, -1, 2, 8};
+ *  int stencil[10] = { 1, 0, 1,  0, 1, 0, 1,  0, 1, 0};
+ * 
+ *  thrust::negate<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  thrust::transform_if(data, data + 10, stencil, data, op, identity); // in-place transformation
+ *
+ *  // data is now {5, 0, -2, -3, -2,  4, 0, -1, -2,  8};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename ForwardIterator,
+         typename UnaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator1 first, InputIterator1 last,
+                               InputIterator2 stencil,
+                               ForwardIterator result,
+                               UnaryFunction op,
+                               Predicate pred);
+
+
+/*! This version of \p transform_if conditionally applies a binary function
+ *  to each pair of elements from two input sequences and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in a stencil sequence
+ *  satifies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first1, last1)</tt> and 
+ *  <tt>j = first2 + (i - first1)</tt> in the range <tt>[first2, first2 + (last1 - first1) )</tt>,
+ *  the predicate <tt>pred(*s)</tt> is evaluated, where <tt>s</tt> is the corresponding input
+ *  iterator in the range <tt>[stencil, stencil + (last1 - first1) )</tt>. If this predicate
+ *  evaluates to \c true, the result of <tt>binary_op(*i,*j)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last1 - first1) )</tt>. Otherwise, <tt>binary_op(*i,*j)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *    
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first1 The beginning of the first input sequence.
+ *  \param last1 The end of the first input sequence.
+ *  \param first2 The beginning of the second input sequence.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param binary_op The transformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator1's \c value_type is convertible to \c BinaryFunction's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c BinaryFunction's \c second_argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                         and \c BinaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first1 may equal \p result, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p first2 may equal \p result, but the range <tt>[first2, first2 + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p stencil may equal \p result, but the range <tt>[stencil, stencil + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int input1[6]  = {-5,  0,  2,  3,  2,  4};
+ *  int input2[6]  = { 3,  6, -2,  1,  2,  3};
+ *  int stencil[8] = { 1,  0,  1,  0,  1,  0};
+ *  int output[6];
+ * 
+ *  thrust::plus<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  thrust::transform_if(thrust::host, input1, input1 + 6, input2, stencil, output, op, identity);
+ *
+ *  // output is now {-2,  0,  0,  3,  4,  4};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename ForwardIterator,
+         typename BinaryFunction,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator transform_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                               InputIterator1 first1, InputIterator1 last1,
+                               InputIterator2 first2,
+                               InputIterator3 stencil,
+                               ForwardIterator result,
+                               BinaryFunction binary_op,
+                               Predicate pred);
+
+
+/*! This version of \p transform_if conditionally applies a binary function
+ *  to each pair of elements from two input sequences and stores the result in the corresponding 
+ *  position in an output sequence if the corresponding position in a stencil sequence
+ *  satifies a predicate. Otherwise, the corresponding position in the
+ *  output sequence is not modified.
+ *
+ *  Specifically, for each iterator <tt>i</tt> in the range <tt>[first1, last1)</tt> and 
+ *  <tt>j = first2 + (i - first1)</tt> in the range <tt>[first2, first2 + (last1 - first1) )</tt>,
+ *  the predicate <tt>pred(*s)</tt> is evaluated, where <tt>s</tt> is the corresponding input
+ *  iterator in the range <tt>[stencil, stencil + (last1 - first1) )</tt>. If this predicate
+ *  evaluates to \c true, the result of <tt>binary_op(*i,*j)</tt> is assigned to <tt>*o</tt>,
+ *  where <tt>o</tt> is the corresponding output iterator in the range
+ *  <tt>[result, result + (last1 - first1) )</tt>. Otherwise, <tt>binary_op(*i,*j)</tt> is
+ *  not evaluated and no assignment occurs. The input and output sequences may coincide,
+ *  resulting in an in-place transformation.
+ *    
+ *  \param first1 The beginning of the first input sequence.
+ *  \param last1 The end of the first input sequence.
+ *  \param first2 The beginning of the second input sequence.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param binary_op The transformation operation.
+ *  \param pred The predicate operation.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator1's \c value_type is convertible to \c BinaryFunction's \c first_argument_type.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                         and \c InputIterator2's \c value_type is convertible to \c BinaryFunction's \c second_argument_type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                         and \c BinaryFunction's \c result_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre \p first1 may equal \p result, but the range <tt>[first1, last1)</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p first2 may equal \p result, but the range <tt>[first2, first2 + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *  \pre \p stencil may equal \p result, but the range <tt>[stencil, stencil + (last1 - first1))</tt> shall not overlap the range <tt>[result, result + (last1 - first1))</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_if:
+ *
+ *  \code
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  
+ *  int input1[6]  = {-5,  0,  2,  3,  2,  4};
+ *  int input2[6]  = { 3,  6, -2,  1,  2,  3};
+ *  int stencil[8] = { 1,  0,  1,  0,  1,  0};
+ *  int output[6];
+ * 
+ *  thrust::plus<int> op;
+ *  thrust::identity<int> identity;
+ *
+ *  thrust::transform_if(input1, input1 + 6, input2, stencil, output, op, identity);
+ *
+ *  // output is now {-2,  0,  0,  3,  4,  4};
+ *  \endcode
+ *
+ *  \see thrust::transform
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename ForwardIterator,
+         typename BinaryFunction,
+         typename Predicate>
+  ForwardIterator transform_if(InputIterator1 first1, InputIterator1 last1,
+                               InputIterator2 first2,
+                               InputIterator3 stencil,
+                               ForwardIterator result,
+                               BinaryFunction binary_op,
+                               Predicate pred);
+
+
+/*! \} // end transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/transform.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_reduce.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..11d6b84c3eb12a6ae6310d3cedc0b5a5a2e31028
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_reduce.h
@@ -0,0 +1,194 @@
+/*
+ *  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 transform_reduce.h
+ *  \brief Fused transform / reduction
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup reductions
+ *  \{
+ *  \addtogroup transformed_reductions Transformed Reductions
+ *  \ingroup reductions
+ *  \{
+ */
+
+
+/*! \p transform_reduce fuses the \p transform and \p reduce operations.
+ *  \p transform_reduce is equivalent to performing a transformation defined by
+ *  \p unary_op into a temporary sequence and then performing \p reduce on the
+ *  transformed sequence. In most cases, fusing these two operations together is
+ *  more efficient, since fewer memory reads and writes are required.
+ *
+ *  \p transform_reduce performs a reduction on the transformation of the
+ *  sequence <tt>[first, last)</tt> according to \p unary_op. Specifically,
+ *  \p unary_op is applied to each element of the sequence and then the result
+ *  is reduced to a single value with \p binary_op using the initial value 
+ *  \p init.  Note that the transformation \p unary_op is not applied to 
+ *  the initial value \p init.  The order of reduction is not specified, 
+ *  so \p binary_op must be both commutative and associative. 
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param unary_op The function to apply to each element of the input sequence.
+ *  \param init The result is initialized to this value.
+ *  \param binary_op The reduction operation.
+ *  \return The result of the transformed reduction.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction's \c result_type is convertible to \c OutputType.
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction's \c result_type is convertible to \p OutputType.
+ *
+ *  The following code snippet demonstrates how to use \p transform_reduce
+ *  to compute the maximum value of the absolute value of the elements
+ *  of a range using the \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform_reduce.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/execution_policy.h>
+ *
+ *  template<typename T>
+ *  struct absolute_value : public unary_function<T,T>
+ *  {
+ *    __host__ __device__ T operator()(const T &x) const
+ *    {
+ *      return x < T(0) ? -x : x;
+ *    }
+ *  };
+ *
+ *  ...
+ *
+ *  int data[6] = {-1, 0, -2, -2, 1, -3};
+ *  int result = thrust::transform_reduce(thrust::host,
+ *                                        data, data + 6,
+ *                                        absolute_value<int>(),
+ *                                        0,
+ *                                        thrust::maximum<int>());
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see \c transform
+ *  \see \c reduce
+ */
+template<typename DerivedPolicy,
+         typename InputIterator, 
+         typename UnaryFunction, 
+         typename OutputType,
+         typename BinaryFunction>
+__host__ __device__
+  OutputType transform_reduce(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                              InputIterator first,
+                              InputIterator last,
+                              UnaryFunction unary_op,
+                              OutputType init,
+                              BinaryFunction binary_op);
+
+
+/*! \p transform_reduce fuses the \p transform and \p reduce operations.
+ *  \p transform_reduce is equivalent to performing a transformation defined by
+ *  \p unary_op into a temporary sequence and then performing \p reduce on the
+ *  transformed sequence. In most cases, fusing these two operations together is
+ *  more efficient, since fewer memory reads and writes are required.
+ *
+ *  \p transform_reduce performs a reduction on the transformation of the
+ *  sequence <tt>[first, last)</tt> according to \p unary_op. Specifically,
+ *  \p unary_op is applied to each element of the sequence and then the result
+ *  is reduced to a single value with \p binary_op using the initial value 
+ *  \p init.  Note that the transformation \p unary_op is not applied to 
+ *  the initial value \p init.  The order of reduction is not specified, 
+ *  so \p binary_op must be both commutative and associative. 
+ *
+ *  \param first The beginning of the sequence.
+ *  \param last The end of the sequence.
+ *  \param unary_op The function to apply to each element of the input sequence.
+ *  \param init The result is initialized to this value.
+ *  \param binary_op The reduction operation.
+ *  \return The result of the transformed reduction.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is convertible to \p UnaryFunction's \c argument_type.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>,
+ *          and \p UnaryFunction's \c result_type is convertible to \c OutputType.
+ *  \tparam OutputType is a model of <a href="https://en.cppreference.com/w/cpp/named_req/CopyAssignable">Assignable</a>,
+ *          and is convertible to \p BinaryFunction's \c first_argument_type and \c second_argument_type.
+ *  \tparam BinaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>,
+ *          and \p BinaryFunction's \c result_type is convertible to \p OutputType.
+ *
+ *  The following code snippet demonstrates how to use \p transform_reduce
+ *  to compute the maximum value of the absolute value of the elements
+ *  of a range.
+ *
+ *  \code
+ *  #include <thrust/transform_reduce.h>
+ *  #include <thrust/functional.h>
+ *
+ *  template<typename T>
+ *  struct absolute_value : public unary_function<T,T>
+ *  {
+ *    __host__ __device__ T operator()(const T &x) const
+ *    {
+ *      return x < T(0) ? -x : x;
+ *    }
+ *  };
+ *
+ *  ...
+ *
+ *  int data[6] = {-1, 0, -2, -2, 1, -3};
+ *  int result = thrust::transform_reduce(data, data + 6,
+ *                                        absolute_value<int>(),
+ *                                        0,
+ *                                        thrust::maximum<int>());
+ *  // result == 3
+ *  \endcode
+ *
+ *  \see \c transform
+ *  \see \c reduce
+ */
+template<typename InputIterator, 
+         typename UnaryFunction, 
+         typename OutputType,
+         typename BinaryFunction>
+  OutputType transform_reduce(InputIterator first,
+                              InputIterator last,
+                              UnaryFunction unary_op,
+                              OutputType init,
+                              BinaryFunction binary_op);
+
+
+/*! \} // end transformed_reductions
+ *  \} // end reductions
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/transform_reduce.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_scan.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c0fe81166806eb3c0d8e0557fcdc36505a30062
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/transform_scan.h
@@ -0,0 +1,320 @@
+/*
+ *  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 transform_scan.h
+ *  \brief Fused transform / prefix-sum
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup prefixsums Prefix Sums
+ *  \ingroup algorithms
+ *  \{
+ */
+	
+/*! \addtogroup transformed_prefixsums Transformed Prefix Sums
+ *  \ingroup prefixsums
+ *  \{
+ */
+
+
+/*! \p transform_inclusive_scan fuses the \p transform and \p inclusive_scan
+ *  operations.  \p transform_inclusive_scan is equivalent to performing a
+ *  tranformation defined by \p unary_op into a temporary sequence and then
+ *  performing an \p inclusive_scan on the tranformed sequence.  In most
+ *  cases, fusing these two operations together is more efficient, since
+ *  fewer memory reads and writes are required. In \p transform_inclusive_scan,
+ *  <tt>unary_op(\*first)</tt> is assigned to <tt>\*result</tt> and the result
+ *  of <tt>binary_op(unary_op(\*first), unary_op(\*(first + 1)))</tt> is
+ *  assigned to <tt>\*(result + 1)</tt>, and so on.  The transform scan
+ *  operation is permitted to be in-place.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param unary_op The function used to tranform the input sequence.
+ *  \param binary_op The associatve operator used to 'sum' transformed values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                               and \c InputIterator's \c value_type is convertible to \c unary_op's input type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                               and accepts inputs of \c InputIterator's \c value_type.  \c UnaryFunction's result_type
+ *                               is convertable to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_inclusive_scan using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform_scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::negate<int> unary_op;
+ *  thrust::plus<int> binary_op;
+ *
+ *  thrust::transform_inclusive_scan(thrust::host, data, data + 6, data, unary_op, binary_op); // in-place scan
+ *
+ *  // data is now {-1, -1, -3, -5, -6, -9}
+ *  \endcode
+ *
+ *  \see \p transform
+ *  \see \p inclusive_scan
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          AssociativeOperator binary_op);
+
+
+/*! \p transform_inclusive_scan fuses the \p transform and \p inclusive_scan
+ *  operations.  \p transform_inclusive_scan is equivalent to performing a
+ *  tranformation defined by \p unary_op into a temporary sequence and then
+ *  performing an \p inclusive_scan on the tranformed sequence.  In most
+ *  cases, fusing these two operations together is more efficient, since
+ *  fewer memory reads and writes are required. In \p transform_inclusive_scan,
+ *  <tt>unary_op(\*first)</tt> is assigned to <tt>\*result</tt> and the result
+ *  of <tt>binary_op(unary_op(\*first), unary_op(\*(first + 1)))</tt> is
+ *  assigned to <tt>\*(result + 1)</tt>, and so on.  The transform scan
+ *  operation is permitted to be in-place.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param unary_op The function used to tranform the input sequence.
+ *  \param binary_op The associatve operator used to 'sum' transformed values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                               and \c InputIterator's \c value_type is convertible to \c unary_op's input type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                               and accepts inputs of \c InputIterator's \c value_type.  \c UnaryFunction's result_type
+ *                               is convertable to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_inclusive_scan
+ *
+ *  \code
+ *  #include <thrust/transform_scan.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::negate<int> unary_op;
+ *  thrust::plus<int> binary_op;
+ *
+ *  thrust::transform_inclusive_scan(data, data + 6, data, unary_op, binary_op); // in-place scan
+ *
+ *  // data is now {-1, -1, -3, -5, -6, -9}
+ *  \endcode
+ *
+ *  \see \p transform
+ *  \see \p inclusive_scan
+ *
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename AssociativeOperator>
+  OutputIterator transform_inclusive_scan(InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          AssociativeOperator binary_op);
+
+
+/*! \p transform_exclusive_scan fuses the \p transform and \p exclusive_scan
+ *  operations.  \p transform_exclusive_scan is equivalent to performing a
+ *  tranformation defined by \p unary_op into a temporary sequence and then
+ *  performing an \p exclusive_scan on the tranformed sequence.  In most
+ *  cases, fusing these two operations together is more efficient, since
+ *  fewer memory reads and writes are required. In 
+ *  \p transform_exclusive_scan, \p init is assigned to <tt>\*result</tt> 
+ *  and the result of <tt>binary_op(init, unary_op(\*first))</tt> is assigned
+ *  to <tt>\*(result + 1)</tt>, and so on.  The transform scan operation is 
+ *  permitted to be in-place.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param unary_op The function used to tranform the input sequence.
+ *  \param init The initial value of the \p exclusive_scan
+ *  \param binary_op The associatve operator used to 'sum' transformed values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                               and \c InputIterator's \c value_type is convertible to \c unary_op's input type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                               and accepts inputs of \c InputIterator's \c value_type.  \c UnaryFunction's result_type
+ *                               is convertable to \c OutputIterator's \c value_type.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_exclusive_scan using the
+ *  \p thrust::host execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/transform_scan.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::negate<int> unary_op;
+ *  thrust::plus<int> binary_op;
+ *
+ *  thrust::transform_exclusive_scan(thrust::host, data, data + 6, data, unary_op, 4, binary_op); // in-place scan
+ *
+ *  // data is now {4, 3, 3, 1, -1, -2}
+ *  \endcode
+ *
+ *  \see \p transform
+ *  \see \p exclusive_scan
+ *
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename UnaryFunction,
+         typename T,
+         typename AssociativeOperator>
+__host__ __device__
+  OutputIterator transform_exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator result,
+                                          UnaryFunction unary_op,
+                                          T init,
+                                          AssociativeOperator binary_op);
+
+
+/*! \p transform_exclusive_scan fuses the \p transform and \p exclusive_scan
+ *  operations.  \p transform_exclusive_scan is equivalent to performing a
+ *  tranformation defined by \p unary_op into a temporary sequence and then
+ *  performing an \p exclusive_scan on the tranformed sequence.  In most
+ *  cases, fusing these two operations together is more efficient, since
+ *  fewer memory reads and writes are required. In 
+ *  \p transform_exclusive_scan, \p init is assigned to <tt>\*result</tt> 
+ *  and the result of <tt>binary_op(init, unary_op(\*first))</tt> is assigned
+ *  to <tt>\*(result + 1)</tt>, and so on.  The transform scan operation is 
+ *  permitted to be in-place.
+ *
+ *  \param first The beginning of the input sequence.
+ *  \param last The end of the input sequence.
+ *  \param result The beginning of the output sequence.
+ *  \param unary_op The function used to tranform the input sequence.
+ *  \param init The initial value of the \p exclusive_scan
+ *  \param binary_op The associatve operator used to 'sum' transformed values.
+ *  \return The end of the output sequence.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>
+ *                               and \c InputIterator's \c value_type is convertible to \c unary_op's input type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam UnaryFunction is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/unary_function">Unary Function</a>
+ *                               and accepts inputs of \c InputIterator's \c value_type.  \c UnaryFunction's result_type
+ *                               is convertable to \c OutputIterator's \c value_type.
+ *  \tparam T is convertible to \c OutputIterator's \c value_type.
+ *  \tparam AssociativeOperator is a model of <a href="https://en.cppreference.com/w/cpp/utility/functional/binary_function">Binary Function</a>
+ *                              and \c AssociativeOperator's \c result_type is
+ *                              convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p transform_exclusive_scan
+ *
+ *  \code
+ *  #include <thrust/transform_scan.h>
+ *  
+ *  int data[6] = {1, 0, 2, 2, 1, 3};
+ *
+ *  thrust::negate<int> unary_op;
+ *  thrust::plus<int> binary_op;
+ *
+ *  thrust::transform_exclusive_scan(data, data + 6, data, unary_op, 4, binary_op); // in-place scan
+ *
+ *  // data is now {4, 3, 3, 1, -1, -2}
+ *  \endcode
+ *
+ *  \see \p transform
+ *  \see \p exclusive_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);
+
+
+/*! \} // end transformed_prefixsums
+ */
+
+
+/*! \} // end prefixsums
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/transform_scan.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tuple.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tuple.h
new file mode 100644
index 0000000000000000000000000000000000000000..04f3154a3b3b09cc8bd29f81bdf6b5ebc76ac883
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/tuple.h
@@ -0,0 +1,575 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file tuple.h
+ *  \brief A type encapsulating a heterogeneous collection of elements.
+ */
+
+/*
+ * Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/tuple.inl>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup utility
+ *  \{
+ */
+
+/*! \addtogroup tuple
+ *  \{
+ */
+
+/*! \cond
+ */
+
+struct null_type;
+
+/*! \endcond
+ */
+
+/*! This metafunction returns the type of a
+ *  \p tuple's <tt>N</tt>th element.
+ *
+ *  \tparam N This parameter selects the element of interest.
+ *  \tparam T A \c tuple type of interest.
+ *
+ *  \see pair
+ *  \see tuple
+ */
+template <size_t N, class T> struct tuple_element;
+
+/*! This metafunction returns the number of elements
+ *  of a \p tuple type of interest.
+ *
+ *  \tparam T A \c tuple type of interest.
+ *
+ *  \see pair
+ *  \see tuple
+ */
+template <class T> struct tuple_size;
+
+
+// get function for non-const cons-lists, returns a reference to the element
+
+/*! The \p get function returns a reference to a \p tuple element of
+ *  interest.
+ *
+ *  \param t A reference to a \p tuple of interest.
+ *  \return A reference to \p t's <tt>N</tt>th element.
+ *
+ *  \tparam N The index of the element of interest.
+ *
+ *  The following code snippet demonstrates how to use \p get to print
+ *  the value of a \p tuple element.
+ *
+ *  \code
+ *  #include <thrust/tuple.h>
+ *  #include <iostream>
+ *  ...
+ *  thrust::tuple<int, const char *> t(13, "thrust");
+ *
+ *  std::cout << "The 1st value of t is " << thrust::get<0>(t) << std::endl;
+ *  \endcode
+ *
+ *  \see pair
+ *  \see tuple
+ */
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::non_const_type
+get(detail::cons<HT, TT>& t);
+
+
+/*! The \p get function returns a \c const reference to a \p tuple element of
+ *  interest.
+ *
+ *  \param t A reference to a \p tuple of interest.
+ *  \return A \c const reference to \p t's <tt>N</tt>th element.
+ *
+ *  \tparam N The index of the element of interest.
+ *
+ *  The following code snippet demonstrates how to use \p get to print
+ *  the value of a \p tuple element.
+ *
+ *  \code
+ *  #include <thrust/tuple.h>
+ *  #include <iostream>
+ *  ...
+ *  thrust::tuple<int, const char *> t(13, "thrust");
+ *
+ *  std::cout << "The 1st value of t is " << thrust::get<0>(t) << std::endl;
+ *  \endcode
+ *
+ *  \see pair
+ *  \see tuple
+ */
+template<int N, class HT, class TT>
+__host__ __device__
+inline typename access_traits<
+                  typename tuple_element<N, detail::cons<HT, TT> >::type
+                >::const_type
+get(const detail::cons<HT, TT>& t);
+
+
+
+/*! \brief \p tuple is a class template that can be instantiated with up to ten
+ *  arguments. Each template argument specifies the type of element in the \p
+ *  tuple. Consequently, tuples are heterogeneous, fixed-size collections of
+ *  values. An instantiation of \p tuple with two arguments is similar to an
+ *  instantiation of \p pair with the same two arguments. Individual elements
+ *  of a \p tuple may be accessed with the \p get function.
+ *
+ *  \tparam TN The type of the <tt>N</tt> \c tuple element. Thrust's \p tuple
+ *          type currently supports up to ten elements.
+ *
+ *  The following code snippet demonstrates how to create a new \p tuple object
+ *  and inspect and modify the value of its elements.
+ *
+ *  \code
+ *  #include <thrust/tuple.h>
+ *  #include <iostream>
+ *  
+ *  int main() {
+ *    // Create a tuple containing an `int`, a `float`, and a string.
+ *    thrust::tuple<int, float, const char*> t(13, 0.1f, "thrust");
+ *
+ *    // Individual members are accessed with the free function `get`.
+ *    std::cout << "The first element's value is " << thrust::get<0>(t) << std::endl;
+ *
+ *    // ... or the member function `get`.
+ *    std::cout << "The second element's value is " << t.get<1>() << std::endl;
+ *
+ *    // We can also modify elements with the same function.
+ *    thrust::get<0>(t) += 10;
+ *  }
+ *  \endcode
+ *
+ *  \see pair
+ *  \see get
+ *  \see make_tuple
+ *  \see tuple_element
+ *  \see tuple_size
+ *  \see tie
+ */
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+  class tuple
+  /*! \cond
+   */
+    : public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+  /*! \endcond
+   */
+{
+  /*! \cond
+   */
+
+  private:
+  typedef typename detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
+
+  /*! \endcond
+   */
+
+  public:
+
+  /*! \p tuple's no-argument constructor initializes each element.
+   */
+  inline __host__ __device__
+  tuple(void) {}
+
+  /*! \p tuple's one-argument constructor copy constructs the first element from the given parameter
+   *     and intializes all other elements.
+   *  \param t0 The value to assign to this \p tuple's first element.
+   */
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0)
+    : inherited(t0,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  /*! \p tuple's one-argument constructor copy constructs the first two elements from the given parameters
+   *     and intializes all other elements.
+   *  \param t0 The value to assign to this \p tuple's first element.
+   *  \param t1 The value to assign to this \p tuple's second element.
+   *  \note \p tuple's constructor has ten variants of this form, the rest of which are ommitted here for brevity.
+   */
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1)
+    : inherited(t0, t1,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  /*! \cond
+   */
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2)
+    : inherited(t0, t1, t2,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3)
+    : inherited(t0, t1, t2, t3,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4)
+    : inherited(t0, t1, t2, t3, t4,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5)
+    : inherited(t0, t1, t2, t3, t4, t5,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6)
+    : inherited(t0, t1, t2, t3, t4, t5, t6,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7,
+                static_cast<const null_type&>(null_type()),
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8,
+                static_cast<const null_type&>(null_type())) {}
+
+  inline __host__ __device__
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8,
+        typename access_traits<T9>::parameter_type t9)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
+
+
+  template<class U1, class U2>
+  inline __host__ __device__
+  tuple(const detail::cons<U1, U2>& p) : inherited(p) {}
+
+  __thrust_exec_check_disable__
+  template <class U1, class U2>
+  inline __host__ __device__
+  tuple& operator=(const detail::cons<U1, U2>& k)
+  {
+    inherited::operator=(k);
+    return *this;
+  }
+
+  /*! \endcond
+   */
+
+  /*! This assignment operator allows assigning the first two elements of this \p tuple from a \p pair.
+   *  \param k A \p pair to assign from.
+   */
+  __thrust_exec_check_disable__
+  template <class U1, class U2>
+  __host__ __device__ inline
+  tuple& operator=(const thrust::pair<U1, U2>& k) {
+    //BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
+    this->head = k.first;
+    this->tail.head = k.second;
+    return *this;
+  }
+
+  /*! \p swap swaps the elements of two <tt>tuple</tt>s.
+   *
+   *  \param t The other <tt>tuple</tt> with which to swap.
+   */
+  inline __host__ __device__
+  void swap(tuple &t)
+  {
+    inherited::swap(t);
+  }
+};
+
+/*! \cond
+ */
+
+template <>
+class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
+  public null_type
+{
+public:
+  typedef null_type inherited;
+};
+
+/*! \endcond
+ */
+
+
+/*! This version of \p make_tuple creates a new \c tuple object from a
+ *  single object.
+ *
+ *  \param t0 The object to copy from.
+ *  \return A \p tuple object with a single member which is a copy of \p t0.
+ */
+template<class T0>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0>::type
+    make_tuple(const T0& t0);
+
+/*! This version of \p make_tuple creates a new \c tuple object from two
+ *  objects.
+ *
+ *  \param t0 The first object to copy from.
+ *  \param t1 The second object to copy from.
+ *  \return A \p tuple object with two members which are copies of \p t0
+ *          and \p t1.
+ *
+ *  \note \p make_tuple has ten variants, the rest of which are omitted here
+ *        for brevity.
+ */
+template<class T0, class T1>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1>::type
+    make_tuple(const T0& t0, const T1& t1);
+
+/*! This version of \p tie creates a new \c tuple whose single element is
+ *  a reference which refers to this function's argument.
+ *
+ *  \param t0 The object to reference.
+ *  \return A \p tuple object with one member which is a reference to \p t0.
+ */
+template<typename T0>
+__host__ __device__ inline
+tuple<T0&> tie(T0& t0);
+
+/*! This version of \p tie creates a new \c tuple of references object which
+ *  refers to this function's arguments.
+ *
+ *  \param t0 The first object to reference.
+ *  \param t1 The second object to reference.
+ *  \return A \p tuple object with two members which are references to \p t0
+ *          and \p t1.
+ *
+ *  \note \p tie has ten variants, the rest of which are omitted here for
+ *           brevity.
+ */
+template<typename T0, typename T1>
+__host__ __device__ inline
+tuple<T0&,T1&> tie(T0& t0, T1& t1);
+
+/*! \p swap swaps the contents of two <tt>tuple</tt>s.
+ *
+ *  \param x The first \p tuple to swap.
+ *  \param y The second \p tuple to swap.
+ */
+template<
+  typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9,
+  typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9
+>
+inline __host__ __device__
+void swap(tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> &x,
+          tuple<U0,U1,U2,U3,U4,U5,U6,U7,U8,U9> &y);
+
+
+
+/*! \cond
+ */
+
+template<class T0, class T1, class T2>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2);
+
+template<class T0, class T1, class T2, class T3>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3);
+
+template<class T0, class T1, class T2, class T3, class T4>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4);
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5);
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6);
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7);
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8);
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
+__host__ __device__ inline
+  typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+    make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9);
+
+template<typename T0, typename T1, typename T2>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&> tie(T0 &t0, T1 &t1, T2 &t2);
+
+template<typename T0, typename T1, typename T2, typename T3>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8);
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+__host__ __device__ inline
+tuple<T0&,T1&,T2&,T3&,T4&,T5&,T6&,T7&,T8&,T9&> tie(T0 &t0, T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9);
+
+
+__host__ __device__ inline
+bool operator==(const null_type&, const null_type&);
+
+__host__ __device__ inline
+bool operator>=(const null_type&, const null_type&);
+
+__host__ __device__ inline
+bool operator<=(const null_type&, const null_type&);
+
+__host__ __device__ inline
+bool operator!=(const null_type&, const null_type&);
+
+__host__ __device__ inline
+bool operator<(const null_type&, const null_type&);
+
+__host__ __device__ inline
+bool operator>(const null_type&, const null_type&);
+
+/*! \endcond
+ */
+
+/*! \} // tuple
+ */
+
+/*! \} // utility
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..94c2763e3e4639fe98fe2a9f6f543f3690ba30f7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_copy.h
@@ -0,0 +1,299 @@
+/*
+ *  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 uninitialized_copy.h
+ *  \brief Copy construction into a range of uninitialized elements from a source range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup copying
+ *  \{
+ */
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a constructor.
+ *  Occasionally, however, it is useful to separate those two operations.
+ *  If each iterator in the range <tt>[result, result + (last - first))</tt> points
+ *  to uninitialized memory, then \p uninitialized_copy creates a copy of
+ *  <tt>[first, last)</tt> in that range. That is, for each iterator \c i in
+ *  the input, \p uninitialized_copy creates a copy of \c *i in the location pointed
+ *  to by the corresponding iterator in the output range by \p ForwardIterator's
+ *  \c value_type's copy constructor with *i as its argument.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the input range to copy from.
+ *  \param last The last element of the input range to copy from.
+ *  \param result The first element of the output range to copy to.
+ *  \return An iterator pointing to the last element of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that takes
+ *          a single argument whose type is \p InputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_copy to initialize
+ *  a range of uninitialized memory using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/uninitialized_copy.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_vector<Int> input(N, val);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_copy(thrust::device, input.begin(), input.end(), array);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_copy
+ *  \see \c copy
+ *  \see \c uninitialized_fill
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename DerivedPolicy, typename InputIterator, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                     InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a constructor.
+ *  Occasionally, however, it is useful to separate those two operations.
+ *  If each iterator in the range <tt>[result, result + (last - first))</tt> points
+ *  to uninitialized memory, then \p uninitialized_copy creates a copy of
+ *  <tt>[first, last)</tt> in that range. That is, for each iterator \c i in
+ *  the input, \p uninitialized_copy creates a copy of \c *i in the location pointed
+ *  to by the corresponding iterator in the output range by \p ForwardIterator's
+ *  \c value_type's copy constructor with *i as its argument.
+ *
+ *  \param first The first element of the input range to copy from.
+ *  \param last The last element of the input range to copy from.
+ *  \param result The first element of the output range to copy to.
+ *  \return An iterator pointing to the last element of the output range.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that takes
+ *          a single argument whose type is \p InputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_copy to initialize
+ *  a range of uninitialized memory.
+ *
+ *  \code
+ *  #include <thrust/uninitialized_copy.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_vector.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_vector<Int> input(N, val);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_copy(input.begin(), input.end(), array);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_copy
+ *  \see \c copy
+ *  \see \c uninitialized_fill
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename InputIterator, typename ForwardIterator>
+  ForwardIterator uninitialized_copy(InputIterator first,
+                                     InputIterator last,
+                                     ForwardIterator result);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a constructor.
+ *  Occasionally, however, it is useful to separate those two operations.
+ *  If each iterator in the range <tt>[result, result + n)</tt> points
+ *  to uninitialized memory, then \p uninitialized_copy_n creates a copy of
+ *  <tt>[first, first + n)</tt> in that range. That is, for each iterator \c i in
+ *  the input, \p uninitialized_copy_n creates a copy of \c *i in the location pointed
+ *  to by the corresponding iterator in the output range by \p InputIterator's
+ *  \c value_type's copy constructor with *i as its argument.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the input range to copy from.
+ *  \param n The number of elements to copy.
+ *  \param result The first element of the output range to copy to.
+ *  \return An iterator pointing to the last element of the output range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Size is an integral type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that takes
+ *          a single argument whose type is \p InputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, first + n)</tt> and the range <tt>[result, result + n)</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_copy to initialize
+ *  a range of uninitialized memory using the \p thrust::device execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/uninitialized_copy.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_vector<Int> input(N, val);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_copy_n(thrust::device, input.begin(), N, array);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_copy
+ *  \see \c uninitialized_copy
+ *  \see \c copy
+ *  \see \c uninitialized_fill
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename ForwardIterator>
+__host__ __device__
+  ForwardIterator uninitialized_copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       InputIterator first,
+                                       Size n,
+                                       ForwardIterator result);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a constructor.
+ *  Occasionally, however, it is useful to separate those two operations.
+ *  If each iterator in the range <tt>[result, result + n)</tt> points
+ *  to uninitialized memory, then \p uninitialized_copy_n creates a copy of
+ *  <tt>[first, first + n)</tt> in that range. That is, for each iterator \c i in
+ *  the input, \p uninitialized_copy_n creates a copy of \c *i in the location pointed
+ *  to by the corresponding iterator in the output range by \p InputIterator's
+ *  \c value_type's copy constructor with *i as its argument.
+ *
+ *  \param first The first element of the input range to copy from.
+ *  \param n The number of elements to copy.
+ *  \param result The first element of the output range to copy to.
+ *  \return An iterator pointing to the last element of the output range.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Size is an integral type.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that takes
+ *          a single argument whose type is \p InputIterator's \c value_type.
+ *
+ *  \pre \p first may equal \p result, but the range <tt>[first, first + n)</tt> and the range <tt>[result, result + n)</tt> shall not overlap otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_copy to initialize
+ *  a range of uninitialized memory.
+ *
+ *  \code
+ *  #include <thrust/uninitialized_copy.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/device_vector.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_vector<Int> input(N, val);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_copy_n(input.begin(), N, array);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_copy
+ *  \see \c uninitialized_copy
+ *  \see \c copy
+ *  \see \c uninitialized_fill
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename InputIterator, typename Size, typename ForwardIterator>
+  ForwardIterator uninitialized_copy_n(InputIterator first,
+                                       Size n,
+                                       ForwardIterator result);
+
+
+/*! \} // copying
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/uninitialized_copy.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_fill.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_fill.h
new file mode 100644
index 0000000000000000000000000000000000000000..b46758a3c8c32d8d881017b65f0f8918f473be56
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/uninitialized_fill.h
@@ -0,0 +1,272 @@
+/*
+ *  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 uninitialized_fill.h
+ *  \brief Copy construction into a range of uninitialized elements from a source value
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup filling
+ *  \ingroup transformations
+ *  \{
+ */
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a
+ *  constructor. Occasionally, however, it is useful to separate those two
+ *  operations. If each iterator in the range <tt>[first, last)</tt> points
+ *  to uninitialized memory, then \p uninitialized_fill creates copies of \c x
+ *  in that range. That is, for each iterator \c i in the range <tt>[first, last)</tt>,
+ *  \p uninitialized_fill creates a copy of \c x in the location pointed to \c i by
+ *  calling \p ForwardIterator's \c value_type's copy constructor.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *  
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the range of interest.
+ *  \param last The last element of the range of interest.
+ *  \param x The value to use as the exemplar of the copy constructor.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that
+ *          takes a single argument of type \p T.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_fill to initialize a range of
+ *  uninitialized memory using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/uninitialized_fill.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_fill(thrust::device, array, array + N, val);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_fill
+ *  \see \c uninitialized_fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_copy
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void uninitialized_fill(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                          ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a
+ *  constructor. Occasionally, however, it is useful to separate those two
+ *  operations. If each iterator in the range <tt>[first, last)</tt> points
+ *  to uninitialized memory, then \p uninitialized_fill creates copies of \c x
+ *  in that range. That is, for each iterator \c i in the range <tt>[first, last)</tt>,
+ *  \p uninitialized_fill creates a copy of \c x in the location pointed to \c i by
+ *  calling \p ForwardIterator's \c value_type's copy constructor.
+ *  
+ *  \param first The first element of the range of interest.
+ *  \param last The last element of the range of interest.
+ *  \param x The value to use as the exemplar of the copy constructor.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that
+ *          takes a single argument of type \p T.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_fill to initialize a range of
+ *  uninitialized memory.
+ *
+ *  \code
+ *  #include <thrust/uninitialized_fill.h>
+ *  #include <thrust/device_malloc.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_fill(array, array + N, val);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_fill
+ *  \see \c uninitialized_fill_n
+ *  \see \c fill
+ *  \see \c uninitialized_copy
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename ForwardIterator, typename T>
+  void uninitialized_fill(ForwardIterator first,
+                          ForwardIterator last,
+                          const T &x);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a
+ *  constructor. Occasionally, however, it is useful to separate those two
+ *  operations. If each iterator in the range <tt>[first, first+n)</tt> points
+ *  to uninitialized memory, then \p uninitialized_fill creates copies of \c x
+ *  in that range. That is, for each iterator \c i in the range <tt>[first, first+n)</tt>,
+ *  \p uninitialized_fill creates a copy of \c x in the location pointed to \c i by
+ *  calling \p ForwardIterator's \c value_type's copy constructor.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *  
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The first element of the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param x The value to use as the exemplar of the copy constructor.
+ *  \return <tt>first+n</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that
+ *          takes a single argument of type \p T.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_fill to initialize a range of
+ *  uninitialized memory using the \p thrust::device execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/uninitialized_fill.h>
+ *  #include <thrust/device_malloc.h>
+ *  #include <thrust/execution_policy.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_fill_n(thrust::device, array, N, val);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_fill
+ *  \see \c uninitialized_fill
+ *  \see \c fill
+ *  \see \c uninitialized_copy_n
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename DerivedPolicy, typename ForwardIterator, typename Size, typename T>
+__host__ __device__
+  ForwardIterator uninitialized_fill_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                                       ForwardIterator first,
+                                       Size n,
+                                       const T &x);
+
+
+/*! In \c thrust, the function \c thrust::device_new allocates memory for
+ *  an object and then creates an object at that location by calling a
+ *  constructor. Occasionally, however, it is useful to separate those two
+ *  operations. If each iterator in the range <tt>[first, first+n)</tt> points
+ *  to uninitialized memory, then \p uninitialized_fill creates copies of \c x
+ *  in that range. That is, for each iterator \c i in the range <tt>[first, first+n)</tt>,
+ *  \p uninitialized_fill creates a copy of \c x in the location pointed to \c i by
+ *  calling \p ForwardIterator's \c value_type's copy constructor.
+ *  
+ *  \param first The first element of the range of interest.
+ *  \param n The size of the range of interest.
+ *  \param x The value to use as the exemplar of the copy constructor.
+ *  \return <tt>first+n</tt>
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          \p ForwardIterator is mutable, and \p ForwardIterator's \c value_type has a constructor that
+ *          takes a single argument of type \p T.
+ *
+ *  The following code snippet demonstrates how to use \p uninitialized_fill to initialize a range of
+ *  uninitialized memory.
+ *
+ *  \code
+ *  #include <thrust/uninitialized_fill.h>
+ *  #include <thrust/device_malloc.h>
+ *  
+ *  struct Int
+ *  {
+ *    __host__ __device__
+ *    Int(int x) : val(x) {}
+ *    int val;
+ *  };  
+ *  ...
+ *  const int N = 137;
+ *
+ *  Int val(46);
+ *  thrust::device_ptr<Int> array = thrust::device_malloc<Int>(N);
+ *  thrust::uninitialized_fill_n(array, N, val);
+ *
+ *  // Int x = array[i];
+ *  // x.val == 46 for all 0 <= i < N
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/memory/uninitialized_fill
+ *  \see \c uninitialized_fill
+ *  \see \c fill
+ *  \see \c uninitialized_copy_n
+ *  \see \c device_new
+ *  \see \c device_malloc
+ */
+template<typename ForwardIterator, typename Size, typename T>
+  ForwardIterator uninitialized_fill_n(ForwardIterator first,
+                                       Size n,
+                                       const T &x);
+
+/*! \} // end filling
+ *  \} // transformations
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/uninitialized_fill.inl>
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/unique.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/unique.h
new file mode 100644
index 0000000000000000000000000000000000000000..234cd4935693ff002f597b76cdf0ea497105d075
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/unique.h
@@ -0,0 +1,1140 @@
+/*
+ *  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 unique.h
+ *  \brief Move unique elements to the front of a range
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup stream_compaction
+ *  \{
+ */
+
+
+/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
+ *  with the same value, \p unique removes all but the first element of 
+ *  the group. The return value is an iterator \c new_last such that 
+ *  no two consecutive elements in the range <tt>[first, new_last)</tt> are
+ *  equal. The iterators in the range <tt>[new_last, last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified.
+ *  \p unique is stable, meaning that the relative order of elements that are
+ *  not removed is unchanged.
+ *
+ *  This version of \p unique uses \c operator== to test for equality.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique to
+ *  compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int *new_end = thrust::unique(thrust::host, A, A + N);
+ *  // The first four values of A are now {1, 3, 2, 1}
+ *  // Values beyond new_end are unspecified.
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique
+ *  \see unique_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last);
+
+
+/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
+ *  with the same value, \p unique removes all but the first element of 
+ *  the group. The return value is an iterator \c new_last such that 
+ *  no two consecutive elements in the range <tt>[first, new_last)</tt> are
+ *  equal. The iterators in the range <tt>[new_last, last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified.
+ *  \p unique is stable, meaning that the relative order of elements that are
+ *  not removed is unchanged.
+ *
+ *  This version of \p unique uses \c operator== to test for equality.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>.
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique to
+ *  compact a sequence of numbers to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int *new_end = thrust::unique(A, A + N);
+ *  // The first four values of A are now {1, 3, 2, 1}
+ *  // Values beyond new_end are unspecified.
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique
+ *  \see unique_copy
+ */
+template<typename ForwardIterator>
+ForwardIterator unique(ForwardIterator first,
+                       ForwardIterator last);
+
+
+/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
+ *  with the same value, \p unique removes all but the first element of 
+ *  the group. The return value is an iterator \c new_last such that 
+ *  no two consecutive elements in the range <tt>[first, new_last)</tt> are
+ *  equal. The iterators in the range <tt>[new_last, last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified.
+ *  \p unique is stable, meaning that the relative order of elements that are
+ *  not removed is unchanged.
+ *
+ *  This version of \p unique uses the function object \p binary_pred to test
+ *  for equality.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique to
+ *  compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int *new_end = thrust::unique(thrust::host, A, A + N, thrust::equal_to<int>());
+ *  // The first four values of A are now {1, 3, 2, 1}
+ *  // Values beyond new_end are unspecified.
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique
+ *  \see unique_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+ForwardIterator unique(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       ForwardIterator first,
+                       ForwardIterator last,
+                       BinaryPredicate binary_pred);
+
+
+/*! For each group of consecutive elements in the range <tt>[first, last)</tt>
+ *  with the same value, \p unique removes all but the first element of 
+ *  the group. The return value is an iterator \c new_last such that 
+ *  no two consecutive elements in the range <tt>[first, new_last)</tt> are
+ *  equal. The iterators in the range <tt>[new_last, last)</tt> are all still
+ *  dereferenceable, but the elements that they point to are unspecified.
+ *  \p unique is stable, meaning that the relative order of elements that are
+ *  not removed is unchanged.
+ *
+ *  This version of \p unique uses the function object \p binary_pred to test
+ *  for equality.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>
+ *
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator is mutable,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique to
+ *  compact a sequence of numbers to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int *new_end = thrust::unique(A, A + N, thrust::equal_to<int>());
+ *  // The first four values of A are now {1, 3, 2, 1}
+ *  // Values beyond new_end are unspecified.
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique
+ *  \see unique_copy
+ */
+template<typename ForwardIterator,
+         typename BinaryPredicate>
+ForwardIterator unique(ForwardIterator first,
+                       ForwardIterator last,
+                       BinaryPredicate binary_pred);
+
+
+/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
+ * to a range beginning with \p result, except that in a consecutive group
+ * of duplicate elements only the first one is copied. The return value
+ * is the end of the range to which the elements are copied. 
+ *
+ * The reason there are two different versions of unique_copy is that there
+ * are two different definitions of what it means for a consecutive group of
+ * elements to be duplicates. In the first version, the test is simple
+ * equality: the elements in a range <tt>[f, l)</tt> are duplicates if,
+ * for every iterator \p i in the range, either <tt>i == f</tt> or else 
+ * <tt>*i == *(i-1)</tt>. In the second, the test is an arbitrary 
+ * \p BinaryPredicate \p binary_pred: the elements in <tt>[f, l)</tt> are
+ * duplicates if, for every iterator \p i in the range, either <tt>i == f</tt>
+ * or else <tt>binary_pred(*i, *(i-1))</tt> is \p true.
+ *
+ * This version of \p unique_copy uses \c operator== to test for equality.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the unique range <tt>[result, result_end)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_copy to
+ *  compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int B[N];
+ *  int *result_end = thrust::unique_copy(thrust::host, A, A + N, B);
+ *  // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
+ *  // Values beyond result_end are unspecified
+ *  \endcode
+ *
+ *  \see unique
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique_copy
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator result);
+
+
+/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
+ * to a range beginning with \p result, except that in a consecutive group
+ * of duplicate elements only the first one is copied. The return value
+ * is the end of the range to which the elements are copied. 
+ *
+ * The reason there are two different versions of unique_copy is that there
+ * are two different definitions of what it means for a consecutive group of
+ * elements to be duplicates. In the first version, the test is simple
+ * equality: the elements in a range <tt>[f, l)</tt> are duplicates if,
+ * for every iterator \p i in the range, either <tt>i == f</tt> or else 
+ * <tt>*i == *(i-1)</tt>. In the second, the test is an arbitrary 
+ * \p BinaryPredicate \p binary_pred: the elements in <tt>[f, l)</tt> are
+ * duplicates if, for every iterator \p i in the range, either <tt>i == f</tt>
+ * or else <tt>binary_pred(*i, *(i-1))</tt> is \p true.
+ *
+ * This version of \p unique_copy uses \c operator== to test for equality.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \return The end of the unique range <tt>[result, result_end)</tt>.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *
+ *  \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_copy to
+ *  compact a sequence of numbers to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int B[N];
+ *  int *result_end = thrust::unique_copy(A, A + N, B);
+ *  // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
+ *  // Values beyond result_end are unspecified
+ *  \endcode
+ *
+ *  \see unique
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique_copy
+ */
+template<typename InputIterator,
+         typename OutputIterator>
+OutputIterator unique_copy(InputIterator first,
+                           InputIterator last,
+                           OutputIterator result);
+
+
+/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
+ * to a range beginning with \p result, except that in a consecutive group
+ * of duplicate elements only the first one is copied. The return value
+ * is the end of the range to which the elements are copied. 
+ *
+ * This version of \p unique_copy uses the function object \c binary_pred 
+ * to test for equality.
+ *
+ * The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[result, result_end)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_copy to
+ *  compact a sequence of numbers to remove consecutive duplicates using the \p thrust::host execution
+ *  policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int B[N];
+ *  int *result_end = thrust::unique_copy(thrust::host, A, A + N, B, thrust::equal_to<int>());
+ *  // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
+ *  // Values beyond result_end are unspecified.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique_copy
+ */
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+__host__ __device__
+OutputIterator unique_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator first,
+                           InputIterator last,
+                           OutputIterator result,
+                           BinaryPredicate binary_pred);
+                       
+
+/*! \p unique_copy copies elements from the range <tt>[first, last)</tt>
+ * to a range beginning with \p result, except that in a consecutive group
+ * of duplicate elements only the first one is copied. The return value
+ * is the end of the range to which the elements are copied. 
+ *
+ * This version of \p unique_copy uses the function object \c binary_pred 
+ * to test for equality.
+ *
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param result The beginning of the output range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[result, result_end)</tt>.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *          and \p InputIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator's \c value_type is convertible to \c OutputIterator's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The range <tt>[first,last)</tt> and the range <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_copy to
+ *  compact a sequence of numbers to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int B[N];
+ *  int *result_end = thrust::unique_copy(A, A + N, B, thrust::equal_to<int>());
+ *  // The first four values of B are now {1, 3, 2, 1} and (result_end - B) is 4
+ *  // Values beyond result_end are unspecified.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see https://en.cppreference.com/w/cpp/algorithm/unique_copy
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename BinaryPredicate>
+OutputIterator unique_copy(InputIterator first,
+                           InputIterator last,
+                           OutputIterator result,
+                           BinaryPredicate binary_pred);
+
+
+/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key removes all but the first element of 
+ *  the group.  Similarly, the corresponding values in the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> 
+ *  are also removed.
+ *
+ *  The return value is a \p pair of iterators <tt>(new_keys_last,new_values_last)</tt>
+ *  such that no two consecutive elements in the range <tt>[keys_first, new_keys_last)</tt>
+ *  are equal.
+ *
+ *  This version of \p unique_by_key uses \c operator== to test for equality and 
+ *  \c project1st to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key range.
+ *  \param keys_last  The end of the key range.
+ *  \param values_first The beginning of the value range.
+ *  \return A pair of iterators at end of the ranges <tt>[key_first, keys_new_last)</tt> and <tt>[values_first, values_new_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1 is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key to
+ *  compact a sequence of key/value pairs to remove consecutive duplicates using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::unique_by_key(thrust::host, A, A + N, B);
+ *
+ *  // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
+ *  // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                ForwardIterator1 keys_first, 
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first);
+
+
+/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key removes all but the first element of 
+ *  the group.  Similarly, the corresponding values in the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> 
+ *  are also removed.
+ *
+ *  The return value is a \p pair of iterators <tt>(new_keys_last,new_values_last)</tt>
+ *  such that no two consecutive elements in the range <tt>[keys_first, new_keys_last)</tt>
+ *  are equal.
+ *
+ *  This version of \p unique_by_key uses \c operator== to test for equality and 
+ *  \c project1st to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the key range.
+ *  \param keys_last  The end of the key range.
+ *  \param values_first The beginning of the value range.
+ *  \return A pair of iterators at end of the ranges <tt>[key_first, keys_new_last)</tt> and <tt>[values_first, values_new_last)</tt>.
+ *
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1 is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2 is mutable.
+ *
+ *  \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key to
+ *  compact a sequence of key/value pairs to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::unique_by_key(A, A + N, B);
+ *
+ *  // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
+ *  // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key
+ */
+template<typename ForwardIterator1,
+         typename ForwardIterator2>
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+  unique_by_key(ForwardIterator1 keys_first, 
+                ForwardIterator1 keys_last,
+                ForwardIterator2 values_first);
+
+
+/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key removes all but the first element of 
+ *  the group.  Similarly, the corresponding values in the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> 
+ *  are also removed.
+ *
+ *  This version of \p unique_by_key uses the function object \c binary_pred
+ *  to test for equality and \c project1st to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the key range.
+ *  \param keys_last  The end of the key range.
+ *  \param values_first The beginning of the value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1 is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2 is mutable.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key to
+ *  compact a sequence of key/value pairs to remove consecutive duplicates using the \p thrust::host
+ *  execution policy for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::unique_by_key(thrust::host, keys, keys + N, values, binary_pred);
+ *
+ *  // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
+ *  // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator1,
+         typename ForwardIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<ForwardIterator1,ForwardIterator2>
+    unique_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                  ForwardIterator1 keys_first, 
+                  ForwardIterator1 keys_last,
+                  ForwardIterator2 values_first,
+                  BinaryPredicate binary_pred);
+
+
+/*! \p unique_by_key is a generalization of \p unique to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key removes all but the first element of 
+ *  the group.  Similarly, the corresponding values in the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> 
+ *  are also removed.
+ *
+ *  This version of \p unique_by_key uses the function object \c binary_pred
+ *  to test for equality and \c project1st to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the key range.
+ *  \param keys_last  The end of the key range.
+ *  \param values_first The beginning of the value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The end of the unique range <tt>[first, new_last)</tt>.
+ *
+ *  \tparam ForwardIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator1 is mutable,
+ *          and \p ForwardIterator's \c value_type is a model of <a href="https://en.cppreference.com/w/cpp/concepts/equality_comparable">Equality Comparable</a>.
+ *  \tparam ForwardIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator2 is mutable.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The range <tt>[keys_first, keys_last)</tt> and the range <tt>[values_first, values_first + (keys_last - keys_first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key to
+ *  compact a sequence of key/value pairs to remove consecutive duplicates.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::unique_by_key(keys, keys + N, values, binary_pred);
+ *
+ *  // The first four keys in A are now {1, 3, 2, 1} and new_end.first - A is 4.
+ *  // The first four values in B are now {9, 8, 5, 3} and new_end.second - B is 4.
+ *  \endcode
+ *
+ *  \see unique
+ *  \see unique_by_key_copy
+ *  \see reduce_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);
+
+
+/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key_copy copies the first element of the group to
+ *  a range beginning with \c keys_result and the corresponding values from the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
+ *  beginning with \c values_result.
+ *
+ *  This version of \p unique_by_key_copy uses \c operator== to test for equality and
+ *  \c project1st to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_result The beginning of the output key range.
+ *  \param values_result The beginning of the output value range.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key_copy to
+ *  compact a sequence of key/value pairs and with equal keys using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::unique_by_key_copy(thrust::host, A, A + N, B, C, D);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 8, 5, 3} and new_end.second - D is 4.
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see reduce_by_key
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 keys_first, 
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_result,
+                       OutputIterator2 values_result);
+
+
+/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key_copy copies the first element of the group to
+ *  a range beginning with \c keys_result and the corresponding values from the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
+ *  beginning with \c values_result.
+ *
+ *  This version of \p unique_by_key_copy uses \c operator== to test for equality and
+ *  \c project1st to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_result The beginning of the output key range.
+ *  \param values_result The beginning of the output value range.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key_copy to
+ *  compact a sequence of key/value pairs and with equal keys.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  new_end = thrust::unique_by_key_copy(A, A + N, B, C, D);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 8, 5, 3} and new_end.second - D is 4.
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see reduce_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_result,
+                     OutputIterator2 values_result);
+
+
+/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key_copy copies the first element of the group to
+ *  a range beginning with \c keys_result and the corresponding values from the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
+ *  beginning with \c values_result.
+ *
+ *  This version of \p unique_by_key_copy uses the function object \c binary_pred
+ *  to test for equality and \c project1st to reduce values with equal keys.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_result The beginning of the output key range.
+ *  \param values_result The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key_copy to
+ *  compact a sequence of key/value pairs and with equal keys using the \p thrust::host execution policy for
+ *  parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::unique_by_key_copy(thrust::host, A, A + N, B, C, D, binary_pred);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 8, 5, 3} and new_end.second - D is 4.
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see reduce_by_key
+ */
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename BinaryPredicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    unique_by_key_copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 keys_first, 
+                       InputIterator1 keys_last,
+                       InputIterator2 values_first,
+                       OutputIterator1 keys_result,
+                       OutputIterator2 values_result,
+                       BinaryPredicate binary_pred);
+
+
+/*! \p unique_by_key_copy is a generalization of \p unique_copy to key-value pairs.
+ *  For each group of consecutive keys in the range <tt>[keys_first, keys_last)</tt>
+ *  that are equal, \p unique_by_key_copy copies the first element of the group to
+ *  a range beginning with \c keys_result and the corresponding values from the range
+ *  <tt>[values_first, values_first + (keys_last - keys_first))</tt> are copied to a range
+ *  beginning with \c values_result.
+ *
+ *  This version of \p unique_by_key_copy uses the function object \c binary_pred
+ *  to test for equality and \c project1st to reduce values with equal keys.
+ *
+ *  \param keys_first The beginning of the input key range.
+ *  \param keys_last  The end of the input key range.
+ *  \param values_first The beginning of the input value range.
+ *  \param keys_result The beginning of the output key range.
+ *  \param values_result The beginning of the output value range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return A pair of iterators at end of the ranges <tt>[keys_result, keys_result_last)</tt> and <tt>[values_result, values_result_last)</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *  \tparam OutputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator1's \c value_type is convertible to \c OutputIterator1's \c value_type.
+ *  \tparam OutputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a> and
+ *          and \p InputIterator2's \c value_type is convertible to \c OutputIterator2's \c value_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  \pre The input ranges shall not overlap either output range.
+ *
+ *  The following code snippet demonstrates how to use \p unique_by_key_copy to
+ *  compact a sequence of key/value pairs and with equal keys.
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1}; // input keys
+ *  int B[N] = {9, 8, 7, 6, 5, 4, 3}; // input values
+ *  int C[N];                         // output keys
+ *  int D[N];                         // output values
+ *
+ *  thrust::pair<int*,int*> new_end;
+ *  thrust::equal_to<int> binary_pred;
+ *  new_end = thrust::unique_by_key_copy(A, A + N, B, C, D, binary_pred);
+ *
+ *  // The first four keys in C are now {1, 3, 2, 1} and new_end.first - C is 4.
+ *  // The first four values in D are now {9, 8, 5, 3} and new_end.second - D is 4.
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key
+ *  \see reduce_by_key
+ */
+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_result,
+                     OutputIterator2 values_result,
+                     BinaryPredicate binary_pred);
+
+
+/*! \p unique_count counts runs of equal elements in the range <tt>[first, last)</tt>
+ *  with the same value, 
+ *
+ *  This version of \p unique_count uses the function object \p binary_pred to test for equality.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The number of runs of equal elements in <tt>[first, new_last)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique_count to
+ *  determine a number of runs of equal elements using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int count = thrust::unique_count(thrust::host, A, A + N, thrust::equal_to<int>());
+ *  // count is now 4
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+  typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred);
+
+
+/*! \p unique_count counts runs of equal elements in the range <tt>[first, last)</tt>
+ *  with the same value, 
+ *
+ *  This version of \p unique_count uses \c operator== to test for equality.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The number of runs of equal elements in <tt>[first, new_last)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique_count to
+ *  determine the number of runs of equal elements using the \p thrust::host execution policy
+ *  for parallelization:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int count = thrust::unique_count(thrust::host, A, A + N);
+ *  // count is now 4
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key_copy
+ */
+template<typename DerivedPolicy,
+         typename ForwardIterator>
+__host__ __device__
+  typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 ForwardIterator first,
+                 ForwardIterator last);
+
+
+/*! \p unique_count counts runs of equal elements in the range <tt>[first, last)</tt>
+ *  with the same value, 
+ *
+ *  This version of \p unique_count uses the function object \p binary_pred to test for equality.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The number of runs of equal elements in <tt>[first, new_last)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique_count to
+ *  determine the number of runs of equal elements:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int count = thrust::unique_count(A, A + N, thrust::equal_to<int>());
+ *  // count is now 4
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key_copy
+ */
+template<typename ForwardIterator,
+         typename BinaryPredicate>
+__host__ __device__
+  typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last,
+                 BinaryPredicate binary_pred);
+
+
+/*! \p unique_count counts runs of equal elements in the range <tt>[first, last)</tt>
+ *  with the same value, 
+ *
+ *  This version of \p unique_count uses \c operator== to test for equality.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the input range.
+ *  \param last  The end of the input range.
+ *  \param binary_pred  The binary predicate used to determine equality.
+ *  \return The number of runs of equal elements in <tt>[first, new_last)</tt>
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam ForwardIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/forward_iterator">Forward Iterator</a>,
+ *          and \p ForwardIterator's \c value_type is convertible to \p BinaryPredicate's \c first_argument_type and to \p BinaryPredicate's \c second_argument_type.
+ *  \tparam BinaryPredicate is a model of <a href="https://en.cppreference.com/w/cpp/named_req/BinaryPredicate">Binary Predicate</a>.
+ *
+ *  The following code snippet demonstrates how to use \p unique_count to
+ *  determine the number of runs of equal elements:
+ *
+ *  \code
+ *  #include <thrust/unique.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  const int N = 7;
+ *  int A[N] = {1, 3, 3, 3, 2, 2, 1};
+ *  int count = thrust::unique_count(thrust::host, A, A + N);
+ *  // count is now 4
+ *  \endcode
+ *
+ *  \see unique_copy
+ *  \see unique_by_key_copy
+ *  \see reduce_by_key_copy
+ */
+template<typename ForwardIterator>
+__host__ __device__
+  typename thrust::iterator_traits<ForwardIterator>::difference_type
+    unique_count(ForwardIterator first,
+                 ForwardIterator last);
+
+
+/*! \} // end stream_compaction
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/unique.inl>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d85cd20de0d4d0a198019565a5ffbe2df901070
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_allocator.h
@@ -0,0 +1,77 @@
+/*
+ *  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.
+ */
+
+
+/*! \file universal_allocator.h
+ *  \brief An allocator which creates new elements in memory accessible to both
+ *         hosts and devices.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #include the device system's vector header
+#define __THRUST_DEVICE_SYSTEM_MEMORY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/memory.h>
+#include __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_MEMORY_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+/** \addtogroup memory_resources Memory Resources
+ *  \ingroup memory_management_classes
+ *  \{
+ */
+
+/*! \brief An allocator which creates new elements in memory accessible by
+ *         both hosts and devices.
+ *
+ *  \see https://en.cppreference.com/w/cpp/named_req/Allocator
+ */
+using thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_allocator;
+
+/*! \p universal_ptr stores a pointer to an object allocated in memory accessible
+ *  to both hosts and devices.
+ *
+ *  Algorithms dispatched with this type of pointer will be dispatched to
+ *  either host or device, depending on which backend you are using. Explicit
+ *  policies (\p thrust::device, etc) can be used to specify where an algorithm
+ *  should be run.
+ *
+ *  \p universal_ptr has pointer semantics: it may be dereferenced safely from
+ *  both hosts and devices and may be manipulated with pointer arithmetic.
+ *
+ *  \p universal_ptr can be created with \p universal_allocator or by explicitly
+ *  calling its constructor with a raw pointer.
+ *
+ *  The raw pointer encapsulated by a \p universal_ptr may be obtained by
+ *  either its <tt>get</tt> method or the \p raw_pointer_cast free function.
+ *
+ *  \note \p universal_ptr is not a smart pointer; it is the programmer's
+ *  responsibility to deallocate memory pointed to by \p universal_ptr.
+ *
+ *  \see host_ptr For the documentation of the complete interface which is
+ *                shared by \p universal_ptr.
+ *  \see raw_pointer_cast
+ */
+template <typename T>
+using universal_ptr =
+  thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_pointer<T>;
+
+/*! \}
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_ptr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d1de19d5f1a30e159d37ed9108024255e9c5a6e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_ptr.h
@@ -0,0 +1,26 @@
+/*
+ *  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.
+ */
+
+
+/*! \file universal_ptr.h
+ *  \brief A pointer to a variable which resides memory accessible to both
+ *         hosts and devices.
+ */
+
+#pragma once
+
+#include <thrust/universal_allocator.h>
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_vector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ce38fd868c208e0d1bdc6ca1539ad16aeb26c00
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/universal_vector.h
@@ -0,0 +1,55 @@
+/*
+ *  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.
+ */
+
+/*! \file
+ *  \brief A dynamically-sizable array of elements which resides in memory
+ *         accessible to both hosts and devices.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/universal_allocator.h>
+
+// #include the device system's vector header
+#define __THRUST_DEVICE_SYSTEM_VECTOR_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/vector.h>
+#include __THRUST_DEVICE_SYSTEM_VECTOR_HEADER
+#undef __THRUST_DEVICE_SYSTEM_VECTOR_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup containers Containers
+ *  \{
+ */
+
+/*! A \p universal_vector is a container that supports random access to elements,
+ *  constant time removal of elements at the end, and linear time insertion
+ *  and removal of elements at the beginning or in the middle. The number of
+ *  elements in a \p universal_vector may vary dynamically; memory management is
+ *  automatic. The memory associated with a \p universal_vector resides in memory
+ *  accessible to hosts and devices.
+ *
+ *  \see https://en.cppreference.com/w/cpp/container/vector
+ *  \see host_vector For the documentation of the complete interface which is
+ *                   shared by \p universal_vector.
+ *  \see device_vector
+ */
+using thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::universal_vector;
+
+/*! \} // containers
+ */
+
+THRUST_NAMESPACE_END
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/version.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..71f1adb6951a4d324b131b2a696265fa17cbb172
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/version.h
@@ -0,0 +1,75 @@
+/*
+ *  Copyright 2008-2022 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file version.h
+ *  \brief Compile-time macros encoding Thrust release version
+ *
+ *         <thrust/version.h> is the only Thrust header that is guaranteed to
+ *         change with every thrust release.
+ *
+ *         It is also the only header that does not cause THRUST_HOST_SYSTEM
+ *         and THRUST_DEVICE_SYSTEM to be defined. This way, a user may include
+ *         this header and inspect THRUST_VERSION before programatically defining
+ *         either of these macros herself.
+ */
+
+#pragma once
+
+//  This is the only Thrust header that is guaranteed to
+//  change with every Thrust release.
+//
+//  THRUST_VERSION % 100 is the sub-minor version
+//  THRUST_VERSION / 100 % 1000 is the minor version
+//  THRUST_VERSION / 100000 is the major version
+//
+//  Because this header does not #include <thrust/detail/config.h>,
+//  it is the only Thrust header that does not cause
+//  THRUST_HOST_SYSTEM and THRUST_DEVICE_SYSTEM to be defined.
+
+/*! \def THRUST_VERSION
+ *  \brief The preprocessor macro \p THRUST_VERSION encodes the version
+ *         number of the Thrust library.
+ *
+ *         <tt>THRUST_VERSION % 100</tt> is the sub-minor version.
+ *         <tt>THRUST_VERSION / 100 % 1000</tt> is the minor version.
+ *         <tt>THRUST_VERSION / 100000</tt> is the major version.
+ */
+#define THRUST_VERSION 200200
+
+/*! \def THRUST_MAJOR_VERSION
+ *  \brief The preprocessor macro \p THRUST_MAJOR_VERSION encodes the
+ *         major version number of the Thrust library.
+ */
+#define THRUST_MAJOR_VERSION     (THRUST_VERSION / 100000)
+
+/*! \def THRUST_MINOR_VERSION
+ *  \brief The preprocessor macro \p THRUST_MINOR_VERSION encodes the
+ *         minor version number of the Thrust library.
+ */
+#define THRUST_MINOR_VERSION     (THRUST_VERSION / 100 % 1000)
+
+/*! \def THRUST_SUBMINOR_VERSION
+ *  \brief The preprocessor macro \p THRUST_SUBMINOR_VERSION encodes the
+ *         sub-minor version number of the Thrust library.
+ */
+#define THRUST_SUBMINOR_VERSION  (THRUST_VERSION % 100)
+
+/*! \def THRUST_PATCH_NUMBER
+ *  \brief The preprocessor macro \p THRUST_PATCH_NUMBER encodes the
+ *         patch number of the Thrust library.
+ *         Legacy; will be 0 for all future releases.
+ */
+#define THRUST_PATCH_NUMBER 0
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/zip_function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/zip_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..7653f9b7f3e1fa7e3f2c44cdbcdf65f9e0683af9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/zip_function.h
@@ -0,0 +1,212 @@
+
+/*! \file thrust/zip_function.h
+ *  \brief Adaptor type that turns an N-ary function object into one that takes
+ *         a tuple of size N so it can easily be used with algorithms taking zip
+ *         iterators
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+#include <thrust/detail/modern_gcc_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011 && !defined(THRUST_LEGACY_GCC)
+
+#include <thrust/tuple.h>
+#include <thrust/type_traits/integer_sequence.h>
+#include <thrust/detail/type_deduction.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup function_objects Function Objects
+ *  \{
+ */
+
+/*! \addtogroup function_object_adaptors Function Object Adaptors
+ *  \ingroup function_objects
+ *  \{
+ */
+
+namespace detail {
+namespace zip_detail {
+
+// Add workaround for decltype(auto) on C++11-only compilers:
+#if THRUST_CPP_DIALECT >= 2014
+
+__thrust_exec_check_disable__
+template <typename Function, typename Tuple, std::size_t... Is>
+__host__ __device__
+decltype(auto) apply_impl(Function&& func, Tuple&& args, index_sequence<Is...>)
+{
+  return func(thrust::get<Is>(THRUST_FWD(args))...);
+}
+
+template <typename Function, typename Tuple>
+__host__ __device__
+decltype(auto) apply(Function&& func, Tuple&& args)
+{
+  constexpr auto tuple_size = thrust::tuple_size<typename std::decay<Tuple>::type>::value;
+  return apply_impl(THRUST_FWD(func), THRUST_FWD(args), make_index_sequence<tuple_size>{});
+}
+
+#else // THRUST_CPP_DIALECT
+
+__thrust_exec_check_disable__
+template <typename Function, typename Tuple, std::size_t... Is>
+__host__ __device__
+auto apply_impl(Function&& func, Tuple&& args, index_sequence<Is...>)
+THRUST_DECLTYPE_RETURNS(func(thrust::get<Is>(THRUST_FWD(args))...))
+
+template <typename Function, typename Tuple>
+__host__ __device__
+auto apply(Function&& func, Tuple&& args)
+THRUST_DECLTYPE_RETURNS(
+    apply_impl(
+      THRUST_FWD(func),
+      THRUST_FWD(args),
+      make_index_sequence<
+        thrust::tuple_size<typename std::decay<Tuple>::type>::value>{})
+)
+
+#endif // THRUST_CPP_DIALECT
+
+} // namespace zip_detail
+} // namespace detail
+
+/*! \p zip_function is a function object that allows the easy use of N-ary
+ *  function objects with \p zip_iterators without redefining them to take a
+ *  \p tuple instead of N arguments.
+ *
+ *  This means that if a functor that takes 2 arguments which could be used with
+ *  the \p transform function and \p device_iterators can be extended to take 3
+ *  arguments and \p zip_iterators without rewriting the functor in terms of
+ *  \p tuple.
+ *
+ *  The \p make_zip_function convenience function is provided to avoid having
+ *  to explicitely define the type of the functor when creating a \p zip_function,
+ *  whic is especially helpful when using lambdas as the functor.
+ *
+ *  \code
+ *  #include <thrust/iterator/zip_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/zip_function.h>
+ *
+ *  struct SumTuple {
+ *    float operator()(Tuple tup) {
+ *      return std::get<0>(tup) + std::get<1>(tup) + std::get<2>(tup);
+ *    }
+ *  };
+ *  struct SumArgs {
+ *    float operator()(float a, float b, float c) {
+ *      return a + b + c;
+ *    }
+ *  };
+ *
+ *  int main() {
+ *    thrust::device_vector<float> A(3);
+ *    thrust::device_vector<float> B(3);
+ *    thrust::device_vector<float> C(3);
+ *    thrust::device_vector<float> D(3);
+ *    A[0] = 0.f; A[1] = 1.f; A[2] = 2.f;
+ *    B[0] = 1.f; B[1] = 2.f; B[2] = 3.f;
+ *    C[0] = 2.f; C[1] = 3.f; C[2] = 4.f;
+ *
+ *    // The following four invocations of transform are equivalent
+ *    // Transform with 3-tuple
+ *    thrust::transform(thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin(), C.begin())),
+ *                      thrust::make_zip_iterator(thrust::make_tuple(A.end(), B.end(), C.end())),
+ *                      D.begin(),
+ *                      SumTuple{});
+ *
+ *    // Transform with 3 parameters
+ *    thrust::zip_function<SumArgs> adapted{};
+ *    thrust::transform(thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin(), C.begin())),
+ *                      thrust::make_zip_iterator(thrust::make_tuple(A.end(), B.end(), C.end())),
+ *                      D.begin(),
+ *                      adapted);
+ *
+ *    // Transform with 3 parameters with convenience function
+ *    thrust::zip_function<SumArgs> adapted{};
+ *    thrust::transform(thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin(), C.begin())),
+ *                      thrust::make_zip_iterator(thrust::make_tuple(A.end(), B.end(), C.end())),
+ *                      D.begin(),
+ *                      thrust::make_zip_function(SumArgs{}));
+ *
+ *    // Transform with 3 parameters with convenience function and lambda
+ *    thrust::zip_function<SumArgs> adapted{};
+ *    thrust::transform(thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin(), C.begin())),
+ *                      thrust::make_zip_iterator(thrust::make_tuple(A.end(), B.end(), C.end())),
+ *                      D.begin(),
+ *                      thrust::make_zip_function([] (float a, float b, float c) {
+ *                                                  return a + b + c;
+ *                                                }));
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_zip_function
+ *  \see zip_iterator
+ */
+template <typename Function>
+class zip_function
+{
+  public:
+     __host__ __device__
+    zip_function(Function func) : func(std::move(func)) {}
+
+// Add workaround for decltype(auto) on C++11-only compilers:
+#if THRUST_CPP_DIALECT >= 2014
+
+    template <typename Tuple>
+    __host__ __device__
+    decltype(auto) operator()(Tuple&& args) const
+    {
+        return detail::zip_detail::apply(func, THRUST_FWD(args));
+    }
+
+#else // THRUST_CPP_DIALECT
+
+    // Can't just use THRUST_DECLTYPE_RETURNS here since we need to use
+    // std::declval for the signature components:
+    template <typename Tuple>
+    __host__ __device__
+    auto operator()(Tuple&& args) const
+    noexcept(noexcept(detail::zip_detail::apply(std::declval<Function>(), THRUST_FWD(args))))
+    THRUST_TRAILING_RETURN(decltype(detail::zip_detail::apply(std::declval<Function>(), THRUST_FWD(args))))
+    {
+        return detail::zip_detail::apply(func, THRUST_FWD(args));
+    }
+
+#endif // THRUST_CPP_DIALECT
+
+  private:
+    mutable Function func;
+};
+
+/*! \p make_zip_function creates a \p zip_function from a function object.
+ *
+ *  \param fun The N-ary function object.
+ *  \return A \p zip_function that takes a N-tuple.
+ *
+ *  \see zip_function
+ */
+template <typename Function>
+__host__ __device__
+zip_function<typename std::decay<Function>::type>
+make_zip_function(Function&& fun)
+{
+    using func_t = typename std::decay<Function>::type;
+    return zip_function<func_t>(THRUST_FWD(fun));
+}
+
+/*! \} // end function_object_adaptors
+ */
+
+/*! \} // end function_objects
+ */
+
+THRUST_NAMESPACE_END
+
+#endif