Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/copy.h

@@ -0,0 +1,34 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// The purpose of this header is to #include the async/copy.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async copy.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/copy.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_COPY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/copy.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_COPY_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_COPY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_COPY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/copy.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_COPY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_COPY_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/for_each.h

@@ -0,0 +1,34 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// The purpose of this header is to #include the async/for_each.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async for_each.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/for_each.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_FOR_EACH_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/for_each.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_FOR_EACH_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_FOR_EACH_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_FOR_EACH_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/for_each.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_FOR_EACH_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_FOR_EACH_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/reduce.h

@@ -0,0 +1,34 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// The purpose of this header is to #include the async/reduce.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async reduce.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/reduce.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_REDUCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/reduce.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_REDUCE_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_REDUCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_REDUCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/reduce.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_REDUCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_REDUCE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/scan.h

@@ -0,0 +1,34 @@
+/*
+ *  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.
+ */
+
+// The purpose of this header is to #include the async/scan.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async scans.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/scan.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_SCAN_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/scan.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_SCAN_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_SCAN_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_SCAN_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/scan.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_SCAN_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_SCAN_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/sort.h

@@ -0,0 +1,34 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// The purpose of this header is to #include the async/sort.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async sort.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/sort.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_SORT_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/sort.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_SORT_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_SORT_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_SORT_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/sort.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_SORT_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_SORT_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/async/transform.h

@@ -0,0 +1,34 @@
+/*
+ *  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 transform of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+// The purpose of this header is to #include the async/transform.h header of the
+// sequential, host, and device systems. It should be #included in any code
+// which uses ADL to dispatch async transform.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+//#include <thrust/system/detail/sequential/async/transform.h>
+
+//#define __THRUST_HOST_SYSTEM_ASYNC_TRANSFORM_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/async/transform.h>
+//#include __THRUST_HOST_SYSTEM_ASYNC_TRANSFORM_HEADER
+//#undef __THRUST_HOST_SYSTEM_ASYNC_TRANSFORM_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_ASYNC_TRANSFORM_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/async/transform.h>
+#include __THRUST_DEVICE_SYSTEM_ASYNC_TRANSFORM_HEADER
+#undef __THRUST_DEVICE_SYSTEM_ASYNC_TRANSFORM_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/per_device_resource.h

@@ -0,0 +1,41 @@
+/*
+ *  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>
+
+// the purpose of this header is to #include the per_device_resource.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch per_device_resource
+
+#include <thrust/system/detail/sequential/per_device_resource.h>
+
+#if 0
+#include <thrust/system/cpp/detail/per_device_resource.h>
+#include <thrust/system/cuda/detail/per_device_resource.h>
+#include <thrust/system/omp/detail/per_device_resource.h>
+#include <thrust/system/tbb/detail/per_device_resource.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_PER_DEVICE_RESOURCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/per_device_resource.h>
+#include __THRUST_HOST_SYSTEM_PER_DEVICE_RESOURCE_HEADER
+#undef __THRUST_HOST_SYSTEM_PER_DEVICE_RESOURCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_PER_DEVICE_RESOURCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/per_device_resource.h>
+#include __THRUST_DEVICE_SYSTEM_PER_DEVICE_RESOURCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_PER_DEVICE_RESOURCE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/reduce.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 reduce.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch reduce
+
+#include <thrust/system/detail/sequential/reduce.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/reduce.h>
+#include <thrust/system/cuda/detail/reduce.h>
+#include <thrust/system/omp/detail/reduce.h>
+#include <thrust/system/tbb/detail/reduce.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_REDUCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/reduce.h>
+#include __THRUST_HOST_SYSTEM_REDUCE_HEADER
+#undef __THRUST_HOST_SYSTEM_REDUCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_REDUCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/reduce.h>
+#include __THRUST_DEVICE_SYSTEM_REDUCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_REDUCE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/reduce_by_key.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 reduce_by_key.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch reduce_by_key
+
+#include <thrust/system/detail/sequential/reduce_by_key.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/reduce_by_key.h>
+#include <thrust/system/cuda/detail/reduce_by_key.h>
+#include <thrust/system/omp/detail/reduce_by_key.h>
+#include <thrust/system/tbb/detail/reduce_by_key.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_REDUCE_BY_KEY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/reduce_by_key.h>
+#include __THRUST_HOST_SYSTEM_REDUCE_BY_KEY_HEADER
+#undef __THRUST_HOST_SYSTEM_REDUCE_BY_KEY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_REDUCE_BY_KEY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/reduce_by_key.h>
+#include __THRUST_DEVICE_SYSTEM_REDUCE_BY_KEY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_REDUCE_BY_KEY_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/remove.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 remove.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch remove
+
+#include <thrust/system/detail/sequential/remove.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/remove.h>
+#include <thrust/system/cuda/detail/remove.h>
+#include <thrust/system/omp/detail/remove.h>
+#include <thrust/system/tbb/detail/remove.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_REMOVE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/remove.h>
+#include __THRUST_HOST_SYSTEM_REMOVE_HEADER
+#undef __THRUST_HOST_SYSTEM_REMOVE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_REMOVE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/remove.h>
+#include __THRUST_DEVICE_SYSTEM_REMOVE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_REMOVE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/replace.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 replace.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch replace
+
+#include <thrust/system/detail/sequential/replace.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/replace.h>
+#include <thrust/system/cuda/detail/replace.h>
+#include <thrust/system/omp/detail/replace.h>
+#include <thrust/system/tbb/detail/replace.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_REPLACE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/replace.h>
+#include __THRUST_HOST_SYSTEM_REPLACE_HEADER
+#undef __THRUST_HOST_SYSTEM_REPLACE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_REPLACE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/replace.h>
+#include __THRUST_DEVICE_SYSTEM_REPLACE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_REPLACE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/reverse.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 reverse.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch reverse
+
+#include <thrust/system/detail/sequential/reverse.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/reverse.h>
+#include <thrust/system/cuda/detail/reverse.h>
+#include <thrust/system/omp/detail/reverse.h>
+#include <thrust/system/tbb/detail/reverse.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_REVERSE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/reverse.h>
+#include __THRUST_HOST_SYSTEM_REVERSE_HEADER
+#undef __THRUST_HOST_SYSTEM_REVERSE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_REVERSE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/reverse.h>
+#include __THRUST_DEVICE_SYSTEM_REVERSE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_REVERSE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/scan.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 scan.h header
+// of the host and device systems. It should be #included in any
+// code which uses adl to dispatch scan
+
+#include <thrust/system/detail/sequential/scan.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/scan.h>
+#include <thrust/system/cuda/detail/scan.h>
+#include <thrust/system/omp/detail/scan.h>
+#include <thrust/system/tbb/detail/scan.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SCAN_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/scan.h>
+#include __THRUST_HOST_SYSTEM_SCAN_HEADER
+#undef __THRUST_HOST_SYSTEM_SCAN_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SCAN_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/scan.h>
+#include __THRUST_DEVICE_SYSTEM_SCAN_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SCAN_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/scan_by_key.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 scan_by_key.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch scan_by_key
+
+#include <thrust/system/detail/sequential/scan_by_key.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/scan_by_key.h>
+#include <thrust/system/cuda/detail/scan_by_key.h>
+#include <thrust/system/omp/detail/scan_by_key.h>
+#include <thrust/system/tbb/detail/scan_by_key.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SCAN_BY_KEY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/scan_by_key.h>
+#include __THRUST_HOST_SYSTEM_SCAN_BY_KEY_HEADER
+#undef __THRUST_HOST_SYSTEM_SCAN_BY_KEY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SCAN_BY_KEY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/scan_by_key.h>
+#include __THRUST_DEVICE_SYSTEM_SCAN_BY_KEY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SCAN_BY_KEY_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/scatter.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 scatter.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch scatter
+
+#include <thrust/system/detail/sequential/scatter.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/scatter.h>
+#include <thrust/system/cuda/detail/scatter.h>
+#include <thrust/system/omp/detail/scatter.h>
+#include <thrust/system/tbb/detail/scatter.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SCATTER_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/scatter.h>
+#include __THRUST_HOST_SYSTEM_SCATTER_HEADER
+#undef __THRUST_HOST_SYSTEM_SCATTER_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SCATTER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/scatter.h>
+#include __THRUST_DEVICE_SYSTEM_SCATTER_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SCATTER_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/sequence.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 sequence.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch sequence
+
+#include <thrust/system/detail/sequential/sequence.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/sequence.h>
+#include <thrust/system/cuda/detail/sequence.h>
+#include <thrust/system/omp/detail/sequence.h>
+#include <thrust/system/tbb/detail/sequence.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SEQUENCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/sequence.h>
+#include __THRUST_HOST_SYSTEM_SEQUENCE_HEADER
+#undef __THRUST_HOST_SYSTEM_SEQUENCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SEQUENCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/sequence.h>
+#include __THRUST_DEVICE_SYSTEM_SEQUENCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SEQUENCE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/set_operations.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 set_operations.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch set_operations
+
+#include <thrust/system/detail/sequential/set_operations.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/set_operations.h>
+#include <thrust/system/cuda/detail/set_operations.h>
+#include <thrust/system/omp/detail/set_operations.h>
+#include <thrust/system/tbb/detail/set_operations.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/set_operations.h>
+#include __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER
+#undef __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/set_operations.h>
+#include __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/sort.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 sort.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch sort
+
+#include <thrust/system/detail/sequential/sort.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/sort.h>
+#include <thrust/system/cuda/detail/sort.h>
+#include <thrust/system/omp/detail/sort.h>
+#include <thrust/system/tbb/detail/sort.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SORT_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/sort.h>
+#include __THRUST_HOST_SYSTEM_SORT_HEADER
+#undef __THRUST_HOST_SYSTEM_SORT_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SORT_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/sort.h>
+#include __THRUST_DEVICE_SYSTEM_SORT_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SORT_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/swap_ranges.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 swap_ranges.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch swap_ranges
+
+#include <thrust/system/detail/sequential/swap_ranges.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/swap_ranges.h>
+#include <thrust/system/cuda/detail/swap_ranges.h>
+#include <thrust/system/omp/detail/swap_ranges.h>
+#include <thrust/system/tbb/detail/swap_ranges.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_SWAP_RANGES_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/swap_ranges.h>
+#include __THRUST_HOST_SYSTEM_SWAP_RANGES_HEADER
+#undef __THRUST_HOST_SYSTEM_SWAP_RANGES_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_SWAP_RANGES_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/swap_ranges.h>
+#include __THRUST_DEVICE_SYSTEM_SWAP_RANGES_HEADER
+#undef __THRUST_DEVICE_SYSTEM_SWAP_RANGES_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/tabulate.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 tabulate.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch tabulate
+
+#include <thrust/system/detail/sequential/tabulate.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/tabulate.h>
+#include <thrust/system/cuda/detail/tabulate.h>
+#include <thrust/system/omp/detail/tabulate.h>
+#include <thrust/system/tbb/detail/tabulate.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_TABULATE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/tabulate.h>
+#include __THRUST_HOST_SYSTEM_TABULATE_HEADER
+#undef __THRUST_HOST_SYSTEM_TABULATE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_TABULATE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/tabulate.h>
+#include __THRUST_DEVICE_SYSTEM_TABULATE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TABULATE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/temporary_buffer.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 temporary_buffer.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch get_temporary_buffer or return_temporary_buffer
+
+#include <thrust/system/detail/sequential/temporary_buffer.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/temporary_buffer.h>
+#include <thrust/system/cuda/detail/temporary_buffer.h>
+#include <thrust/system/omp/detail/temporary_buffer.h>
+#include <thrust/system/tbb/detail/temporary_buffer.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_TEMPORARY_BUFFER_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/temporary_buffer.h>
+#include __THRUST_HOST_SYSTEM_TEMPORARY_BUFFER_HEADER
+#undef __THRUST_HOST_SYSTEM_TEMPORARY_BUFFER_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_TEMPORARY_BUFFER_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/temporary_buffer.h>
+#include __THRUST_DEVICE_SYSTEM_TEMPORARY_BUFFER_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TEMPORARY_BUFFER_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/transform.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 transform.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch transform
+
+#include <thrust/system/detail/sequential/transform.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/transform.h>
+#include <thrust/system/cuda/detail/transform.h>
+#include <thrust/system/omp/detail/transform.h>
+#include <thrust/system/tbb/detail/transform.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_TRANSFORM_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/transform.h>
+#include __THRUST_HOST_SYSTEM_TRANSFORM_HEADER
+#undef __THRUST_HOST_SYSTEM_TRANSFORM_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_TRANSFORM_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/transform.h>
+#include __THRUST_DEVICE_SYSTEM_TRANSFORM_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TRANSFORM_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/transform_reduce.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 transform_reduce.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch transform_reduce
+
+#include <thrust/system/detail/sequential/transform_reduce.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/transform_reduce.h>
+#include <thrust/system/cuda/detail/transform_reduce.h>
+#include <thrust/system/omp/detail/transform_reduce.h>
+#include <thrust/system/tbb/detail/transform_reduce.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/transform_reduce.h>
+#include __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER
+#undef __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/transform_reduce.h>
+#include __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/transform_scan.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 transform_scan.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch transform_scan
+
+#include <thrust/system/detail/sequential/transform_scan.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/transform_scan.h>
+#include <thrust/system/cuda/detail/transform_scan.h>
+#include <thrust/system/omp/detail/transform_scan.h>
+#include <thrust/system/tbb/detail/transform_scan.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_TRANSFORM_SCAN_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/transform_scan.h>
+#include __THRUST_HOST_SYSTEM_TRANSFORM_SCAN_HEADER
+#undef __THRUST_HOST_SYSTEM_TRANSFORM_SCAN_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_TRANSFORM_SCAN_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/transform_scan.h>
+#include __THRUST_DEVICE_SYSTEM_TRANSFORM_SCAN_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TRANSFORM_SCAN_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/uninitialized_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 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 uninitialized_copy.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch uninitialized_copy
+
+#include <thrust/system/detail/sequential/uninitialized_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/uninitialized_copy.h>
+#include <thrust/system/cuda/detail/uninitialized_copy.h>
+#include <thrust/system/omp/detail/uninitialized_copy.h>
+#include <thrust/system/tbb/detail/uninitialized_copy.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_UNINITIALIZED_COPY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/uninitialized_copy.h>
+#include __THRUST_HOST_SYSTEM_UNINITIALIZED_COPY_HEADER
+#undef __THRUST_HOST_SYSTEM_UNINITIALIZED_COPY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_UNINITIALIZED_COPY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/uninitialized_copy.h>
+#include __THRUST_DEVICE_SYSTEM_UNINITIALIZED_COPY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_UNINITIALIZED_COPY_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/uninitialized_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 uninitialized_fill.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch uninitialized_fill
+
+#include <thrust/system/detail/sequential/uninitialized_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/uninitialized_fill.h>
+#include <thrust/system/cuda/detail/uninitialized_fill.h>
+#include <thrust/system/omp/detail/uninitialized_fill.h>
+#include <thrust/system/tbb/detail/uninitialized_fill.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_UNINITIALIZED_FILL_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/uninitialized_fill.h>
+#include __THRUST_HOST_SYSTEM_UNINITIALIZED_FILL_HEADER
+#undef __THRUST_HOST_SYSTEM_UNINITIALIZED_FILL_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_UNINITIALIZED_FILL_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/uninitialized_fill.h>
+#include __THRUST_DEVICE_SYSTEM_UNINITIALIZED_FILL_HEADER
+#undef __THRUST_DEVICE_SYSTEM_UNINITIALIZED_FILL_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/unique.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 unique.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch unique
+
+#include <thrust/system/detail/sequential/unique.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/unique.h>
+#include <thrust/system/cuda/detail/unique.h>
+#include <thrust/system/omp/detail/unique.h>
+#include <thrust/system/tbb/detail/unique.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_UNIQUE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/unique.h>
+#include __THRUST_HOST_SYSTEM_UNIQUE_HEADER
+#undef __THRUST_HOST_SYSTEM_UNIQUE_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_UNIQUE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/unique.h>
+#include __THRUST_DEVICE_SYSTEM_UNIQUE_HEADER
+#undef __THRUST_DEVICE_SYSTEM_UNIQUE_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/adl/unique_by_key.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 unique_by_key.h header
+// of the sequential, host, and device systems. It should be #included in any
+// code which uses adl to dispatch unique_by_key
+
+#include <thrust/system/detail/sequential/unique_by_key.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/unique_by_key.h>
+#include <thrust/system/cuda/detail/unique_by_key.h>
+#include <thrust/system/omp/detail/unique_by_key.h>
+#include <thrust/system/tbb/detail/unique_by_key.h>
+#endif
+
+#define __THRUST_HOST_SYSTEM_UNIQUE_BY_KEY_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/unique_by_key.h>
+#include __THRUST_HOST_SYSTEM_UNIQUE_BY_KEY_HEADER
+#undef __THRUST_HOST_SYSTEM_UNIQUE_BY_KEY_HEADER
+
+#define __THRUST_DEVICE_SYSTEM_UNIQUE_BY_KEY_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/unique_by_key.h>
+#include __THRUST_DEVICE_SYSTEM_UNIQUE_BY_KEY_HEADER
+#undef __THRUST_DEVICE_SYSTEM_UNIQUE_BY_KEY_HEADER
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/adjacent_difference.h

@@ -0,0 +1,57 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT 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 Generic implementation of adjacent_difference.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator adjacent_difference(thrust::execution_policy<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result);
+
+
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__
+OutputIterator adjacent_difference(thrust::execution_policy<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/adjacent_difference.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/adjacent_difference.inl

@@ -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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/adjacent_difference.h>
+#include <thrust/adjacent_difference.h>
+#include <thrust/functional.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/transform.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator adjacent_difference(thrust::execution_policy<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result)
+{
+  typedef typename thrust::iterator_traits<InputIterator>::value_type InputType;
+  thrust::minus<InputType> binary_op;
+
+  return thrust::adjacent_difference(exec, first, last, result, binary_op);
+} // end adjacent_difference()
+
+
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+__host__ __device__
+OutputIterator adjacent_difference(thrust::execution_policy<DerivedPolicy> &exec,
+                                   InputIterator first, InputIterator last,
+                                   OutputIterator result,
+                                   BinaryFunction binary_op)
+{
+  typedef typename thrust::iterator_traits<InputIterator>::value_type InputType;
+
+  if(first == last)
+  {
+    // empty range, nothing to do
+    return result;
+  }
+  else
+  {
+    // an in-place operation is requested, copy the input and call the entry point
+    // XXX a special-purpose kernel would be faster here since
+    // only block boundaries need to be copied
+    thrust::detail::temporary_array<InputType, DerivedPolicy> input_copy(exec, first, last);
+
+    *result = *first;
+    thrust::transform(exec, input_copy.begin() + 1, input_copy.end(), input_copy.begin(), result + 1, binary_op);
+  }
+
+  return result + (last - first);
+}
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/advance.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.
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+template<typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n);
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/advance.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/advance.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/system/detail/generic/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+namespace detail
+{
+
+__thrust_exec_check_disable__
+template<typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n, thrust::incrementable_traversal_tag)
+{
+  while(n)
+  {
+    ++i;
+    --n;
+  } // end while
+} // end advance()
+
+__thrust_exec_check_disable__
+template<typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n, thrust::random_access_traversal_tag)
+{
+  i += n;
+} // end advance()
+
+} // end detail
+
+template<typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n)
+{
+  // dispatch on iterator traversal
+  thrust::system::detail::generic::detail::advance(i, n,
+    typename thrust::iterator_traversal<InputIterator>::type());
+} // end advance()
+
+} // end namespace detail
+} // end namespace generic
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/binary_search.h

@@ -0,0 +1,173 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT 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 Generic implementations of binary search functions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+ForwardIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec, 
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value);
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value, 
+                            StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+ForwardIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value);
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec, 
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value, 
+                            StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+bool binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                   ForwardIterator begin,
+                   ForwardIterator end,
+                   const T& value);
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+bool binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                   ForwardIterator begin,
+                   ForwardIterator end,
+                   const T& value, 
+                   StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin, 
+                           ForwardIterator end,
+                           InputIterator values_begin, 
+                           InputIterator values_end,
+                           OutputIterator output);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin, 
+                           ForwardIterator end,
+                           InputIterator values_begin, 
+                           InputIterator values_end,
+                           OutputIterator output,
+                           StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin, 
+                           ForwardIterator end,
+                           InputIterator values_begin, 
+                           InputIterator values_end,
+                           OutputIterator output);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin, 
+                           ForwardIterator end,
+                           InputIterator values_begin, 
+                           InputIterator values_end,
+                           OutputIterator output,
+                           StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                             ForwardIterator begin, 
+                             ForwardIterator end,
+                             InputIterator values_begin, 
+                             InputIterator values_end,
+                             OutputIterator output);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                             ForwardIterator begin, 
+                             ForwardIterator end,
+                             InputIterator values_begin, 
+                             InputIterator values_end,
+                             OutputIterator output,
+                             StrictWeakOrdering comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator>
+equal_range(thrust::execution_policy<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable &value);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable, typename StrictWeakOrdering>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator>
+equal_range(thrust::execution_policy<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable &value,
+            StrictWeakOrdering comp);
+
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/binary_search.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/binary_search.inl

@@ -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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/distance.h>
+#include <thrust/binary_search.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/binary_search.h>
+
+#include <thrust/for_each.h>
+#include <thrust/detail/function.h>
+#include <thrust/system/detail/generic/scalar/binary_search.h>
+#include <thrust/system/detail/generic/select_system.h>
+
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// XXX WAR circular #inclusion with this forward declaration
+template<typename,typename> class temporary_array;
+
+
+} // end detail
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+namespace detail
+{
+
+
+// short names to avoid nvcc bug
+struct lbf
+{
+  template<typename RandomAccessIterator, typename T, typename StrictWeakOrdering>
+  __host__ __device__
+  typename thrust::iterator_traits<RandomAccessIterator>::difference_type
+    operator()(RandomAccessIterator begin, RandomAccessIterator end, const T& value, StrictWeakOrdering comp)
+  {
+    return thrust::system::detail::generic::scalar::lower_bound(begin, end, value, comp) - begin;
+  }
+};
+
+
+struct ubf
+{
+  template<typename RandomAccessIterator, typename T, typename StrictWeakOrdering>
+  __host__ __device__
+  typename thrust::iterator_traits<RandomAccessIterator>::difference_type
+    operator()(RandomAccessIterator begin, RandomAccessIterator end, const T& value, StrictWeakOrdering comp)
+  {
+    return thrust::system::detail::generic::scalar::upper_bound(begin, end, value, comp) - begin;
+  }
+};
+
+
+struct bsf
+{
+  template<typename RandomAccessIterator, typename T, typename StrictWeakOrdering>
+  __host__ __device__
+  bool operator()(RandomAccessIterator begin, RandomAccessIterator end, const T& value, StrictWeakOrdering comp)
+  {
+    RandomAccessIterator iter = thrust::system::detail::generic::scalar::lower_bound(begin, end, value, comp);
+
+    thrust::detail::wrapped_function<StrictWeakOrdering,bool> wrapped_comp(comp);
+
+    return iter != end && !wrapped_comp(value, *iter);
+  }
+};
+
+
+template<typename ForwardIterator, typename StrictWeakOrdering, typename BinarySearchFunction>
+struct binary_search_functor
+{
+  ForwardIterator begin;
+  ForwardIterator end;
+  StrictWeakOrdering comp;
+  BinarySearchFunction func;
+
+  __host__ __device__
+  binary_search_functor(ForwardIterator begin, ForwardIterator end, StrictWeakOrdering comp, BinarySearchFunction func)
+    : begin(begin), end(end), comp(comp), func(func) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  void operator()(Tuple t)
+  {
+    thrust::get<1>(t) = func(begin, end, thrust::get<0>(t), comp);
+  }
+}; // binary_search_functor
+
+
+// Vector Implementation
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering, typename BinarySearchFunction>
+__host__ __device__
+OutputIterator binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                             ForwardIterator begin,
+                             ForwardIterator end,
+                             InputIterator values_begin,
+                             InputIterator values_end,
+                             OutputIterator output,
+                             StrictWeakOrdering comp,
+                             BinarySearchFunction func)
+{
+  thrust::for_each(exec,
+                   thrust::make_zip_iterator(thrust::make_tuple(values_begin, output)),
+                   thrust::make_zip_iterator(thrust::make_tuple(values_end, output + thrust::distance(values_begin, values_end))),
+                   detail::binary_search_functor<ForwardIterator, StrictWeakOrdering, BinarySearchFunction>(begin, end, comp, func));
+
+  return output + thrust::distance(values_begin, values_end);
+}
+
+
+
+// Scalar Implementation
+template<typename OutputType, typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering, typename BinarySearchFunction>
+__host__ __device__
+OutputType binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                         ForwardIterator begin,
+                         ForwardIterator end,
+                         const T& value,
+                         StrictWeakOrdering comp,
+                         BinarySearchFunction func)
+{
+  // use the vectorized path to implement the scalar version
+
+  // allocate device buffers for value and output
+  thrust::detail::temporary_array<T,DerivedPolicy>          d_value(exec,1);
+  thrust::detail::temporary_array<OutputType,DerivedPolicy> d_output(exec,1);
+
+  { // copy value to device
+    typedef typename thrust::iterator_system<const T*>::type value_in_system_t;
+    value_in_system_t value_in_system;
+    using thrust::system::detail::generic::select_system;
+    thrust::copy_n(select_system(thrust::detail::derived_cast(thrust::detail::strip_const(value_in_system)),
+                                 thrust::detail::derived_cast(thrust::detail::strip_const(exec))),
+                   &value, 1, d_value.begin());
+  }
+
+  // perform the query
+  thrust::system::detail::generic::detail::binary_search(exec, begin, end, d_value.begin(), d_value.end(), d_output.begin(), comp, func);
+
+  OutputType output;
+  { // copy result to host and return
+    typedef typename thrust::iterator_system<OutputType*>::type result_out_system_t;
+    result_out_system_t result_out_system;
+    using thrust::system::detail::generic::select_system;
+    thrust::copy_n(select_system(thrust::detail::derived_cast(thrust::detail::strip_const(exec)),
+                                 thrust::detail::derived_cast(thrust::detail::strip_const(result_out_system))),
+                   d_output.begin(), 1, &output);
+  }
+
+  return output;
+}
+
+
+// this functor differs from thrust::less<T>
+// because it allows the types of lhs & rhs to differ
+// which is required by the binary search functions
+// XXX use C++14 thrust::less<> when it's ready
+struct binary_search_less
+{
+  template<typename T1, typename T2>
+  __host__ __device__
+  bool operator()(const T1& lhs, const T2& rhs) const
+  {
+    return lhs < rhs;
+  }
+};
+
+
+} // end namespace detail
+
+
+//////////////////////
+// Scalar Functions //
+//////////////////////
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+ForwardIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value)
+{
+  namespace p = thrust::placeholders;
+  return thrust::lower_bound(exec, begin, end, value, detail::binary_search_less());
+}
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+  typedef typename thrust::iterator_traits<ForwardIterator>::difference_type difference_type;
+
+  return begin + detail::binary_search<difference_type>(exec, begin, end, value, comp, detail::lbf());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+ForwardIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value)
+{
+  namespace p = thrust::placeholders;
+  return thrust::upper_bound(exec, begin, end, value, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+  typedef typename thrust::iterator_traits<ForwardIterator>::difference_type difference_type;
+
+  return begin + detail::binary_search<difference_type>(exec, begin, end, value, comp, detail::ubf());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+bool binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                   ForwardIterator begin,
+                   ForwardIterator end,
+                   const T& value)
+{
+  return thrust::binary_search(exec, begin, end, value, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+bool binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                   ForwardIterator begin,
+                   ForwardIterator end,
+                   const T& value,
+                   StrictWeakOrdering comp)
+{
+  return detail::binary_search<bool>(exec, begin, end, value, comp, detail::bsf());
+}
+
+
+//////////////////////
+// Vector Functions //
+//////////////////////
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin,
+                           ForwardIterator end,
+                           InputIterator values_begin,
+                           InputIterator values_end,
+                           OutputIterator output)
+{
+  namespace p = thrust::placeholders;
+  return thrust::lower_bound(exec, begin, end, values_begin, values_end, output, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator lower_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin,
+                           ForwardIterator end,
+                           InputIterator values_begin,
+                           InputIterator values_end,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+  return detail::binary_search(exec, begin, end, values_begin, values_end, output, comp, detail::lbf());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin,
+                           ForwardIterator end,
+                           InputIterator values_begin,
+                           InputIterator values_end,
+                           OutputIterator output)
+{
+  namespace p = thrust::placeholders;
+  return thrust::upper_bound(exec, begin, end, values_begin, values_end, output, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator upper_bound(thrust::execution_policy<DerivedPolicy> &exec,
+                           ForwardIterator begin,
+                           ForwardIterator end,
+                           InputIterator values_begin,
+                           InputIterator values_end,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+  return detail::binary_search(exec, begin, end, values_begin, values_end, output, comp, detail::ubf());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                             ForwardIterator begin,
+                             ForwardIterator end,
+                             InputIterator values_begin,
+                             InputIterator values_end,
+                             OutputIterator output)
+{
+  namespace p = thrust::placeholders;
+  return thrust::binary_search(exec, begin, end, values_begin, values_end, output, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator binary_search(thrust::execution_policy<DerivedPolicy> &exec,
+                             ForwardIterator begin,
+                             ForwardIterator end,
+                             InputIterator values_begin,
+                             InputIterator values_end,
+                             OutputIterator output,
+                             StrictWeakOrdering comp)
+{
+  return detail::binary_search(exec, begin, end, values_begin, values_end, output, comp, detail::bsf());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator>
+equal_range(thrust::execution_policy<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable &value)
+{
+  return thrust::equal_range(exec, first, last, value, detail::binary_search_less());
+}
+
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator>
+equal_range(thrust::execution_policy<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T &value,
+            StrictWeakOrdering comp)
+{
+  ForwardIterator lb = thrust::lower_bound(exec, first, last, value, comp);
+  ForwardIterator ub = thrust::upper_bound(exec, first, last, value, comp);
+  return thrust::make_pair(lb, ub);
+}
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/copy.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/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy(thrust::execution_policy<DerivedPolicy> &exec,
+                      InputIterator  first,
+                      InputIterator  last,
+                      OutputIterator result);
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy_n(thrust::execution_policy<DerivedPolicy> &exec,
+                        InputIterator  first,
+                        Size           n,
+                        OutputIterator result);
+
+
+} // end generic
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/copy.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/copy.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/system/detail/generic/copy.h>
+#include <thrust/functional.h>
+#include <thrust/detail/internal_functional.h>
+#include <thrust/transform.h>
+#include <thrust/for_each.h>
+#include <thrust/tuple.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/detail/minimum_system.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy(thrust::execution_policy<DerivedPolicy> &exec,
+                      InputIterator                            first,
+                      InputIterator                            last,
+                      OutputIterator                           result)
+{
+  typedef typename thrust::iterator_value<InputIterator>::type T;
+  return thrust::transform(exec, first, last, result, thrust::identity<T>());
+} // end copy()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy_n(thrust::execution_policy<DerivedPolicy> &exec,
+                        InputIterator                            first,
+                        Size                                     n,
+                        OutputIterator                           result)
+{
+  typedef typename thrust::iterator_value<InputIterator>::type value_type;
+  typedef thrust::identity<value_type>                         xfrm_type;
+
+  typedef thrust::detail::unary_transform_functor<xfrm_type> functor_type;
+
+  typedef thrust::tuple<InputIterator,OutputIterator> iterator_tuple;
+  typedef thrust::zip_iterator<iterator_tuple>        zip_iter;
+
+  zip_iter zipped = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+
+  return thrust::get<1>(thrust::for_each_n(exec, zipped, n, functor_type(xfrm_type())).get_iterator_tuple());
+} // end copy_n()
+
+
+} // end generic
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/copy_if.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>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(thrust::execution_policy<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(thrust::execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator result,
+                          Predicate pred);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/copy_if.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/copy_if.inl

@@ -0,0 +1,160 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 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/copy_if.h>
+#include <thrust/detail/copy_if.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/functional.h>
+#include <thrust/distance.h>
+#include <thrust/transform.h>
+#include <thrust/detail/internal_functional.h>
+#include <thrust/detail/integer_traits.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/scan.h>
+#include <thrust/scatter.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+namespace detail
+{
+
+
+template<typename IndexType,
+         typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+OutputIterator copy_if(thrust::execution_policy<DerivedPolicy> &exec,
+                       InputIterator1 first,
+                       InputIterator1 last,
+                       InputIterator2 stencil,
+                       OutputIterator result,
+                       Predicate pred)
+{
+  THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING(IndexType n = thrust::distance(first, last));
+  
+  // compute {0,1} predicates
+  thrust::detail::temporary_array<IndexType, DerivedPolicy> predicates(exec, n);
+  thrust::transform(exec,
+                    stencil,
+                    stencil + n,
+                    predicates.begin(),
+                    thrust::detail::predicate_to_integral<Predicate,IndexType>(pred));
+  
+  // scan {0,1} predicates
+  thrust::detail::temporary_array<IndexType, DerivedPolicy> scatter_indices(exec, n);
+  thrust::exclusive_scan(exec,
+                         predicates.begin(),
+                         predicates.end(),
+                         scatter_indices.begin(),
+                         static_cast<IndexType>(0),
+                         thrust::plus<IndexType>());
+  
+  // scatter the true elements
+  thrust::scatter_if(exec,
+                     first,
+                     last,
+                     scatter_indices.begin(),
+                     predicates.begin(),
+                     result,
+                     thrust::identity<IndexType>());
+  
+  // find the end of the new sequence
+  IndexType output_size = scatter_indices[n - 1] + predicates[n - 1];
+  
+  return result + output_size;
+}
+
+
+} // end namespace detail
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(thrust::execution_policy<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred)
+{
+  // XXX it's potentially expensive to send [first,last) twice
+  //     we should probably specialize this case for POD
+  //     since we can safely keep the input in a temporary instead
+  //     of doing two loads
+  return thrust::copy_if(exec, first, last, first, result, pred);
+} // end copy_if()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+   OutputIterator copy_if(thrust::execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator result,
+                          Predicate pred)
+{
+  typedef typename thrust::iterator_traits<InputIterator1>::difference_type difference_type;
+  
+  // empty sequence
+  if(first == last)
+    return result;
+  
+  difference_type n = thrust::distance(first, last);
+  
+  // create an unsigned version of n (we know n is positive from the comparison above)
+  // to avoid a warning in the compare below
+  typename thrust::detail::make_unsigned<difference_type>::type unsigned_n(n);
+  
+  // use 32-bit indices when possible (almost always)
+  if(sizeof(difference_type) > sizeof(unsigned int) && unsigned_n > thrust::detail::integer_traits<unsigned int>::const_max)
+  {
+    result = detail::copy_if<difference_type>(exec, first, last, stencil, result, pred);
+  } // end if
+  else
+  {
+    result = detail::copy_if<unsigned int>(exec, first, last, stencil, result, pred);
+  } // end else
+
+  return result;
+} // end copy_if()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/count.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/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template <typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+__host__ __device__
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(thrust::execution_policy<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(thrust::execution_policy<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/count.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/count.inl

@@ -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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/count.h>
+#include <thrust/transform_reduce.h>
+#include <thrust/detail/internal_functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template <typename InputType, typename Predicate, typename CountType>
+struct count_if_transform
+{
+  __host__ __device__
+  count_if_transform(Predicate _pred) : pred(_pred){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  CountType operator()(const InputType& val)
+  {
+    if(pred(val))
+      return 1;
+    else
+      return 0;
+  } // end operator()
+
+  Predicate pred;
+}; // end count_if_transform
+
+
+template <typename DerivedPolicy, typename InputIterator, typename EqualityComparable>
+__host__ __device__
+typename thrust::iterator_traits<InputIterator>::difference_type
+count(thrust::execution_policy<DerivedPolicy> &exec, InputIterator first, InputIterator last, const EqualityComparable& value)
+{
+  using thrust::placeholders::_1;
+
+  return thrust::count_if(exec, first, last, _1 == value);
+} // end count()
+
+
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+typename thrust::iterator_traits<InputIterator>::difference_type
+count_if(thrust::execution_policy<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred)
+{
+  typedef typename thrust::iterator_traits<InputIterator>::value_type InputType;
+  typedef typename thrust::iterator_traits<InputIterator>::difference_type CountType;
+
+  thrust::system::detail::generic::count_if_transform<InputType, Predicate, CountType> unary_op(pred);
+  thrust::plus<CountType> binary_op;
+  return thrust::transform_reduce(exec, first, last, unary_op, CountType(0), binary_op);
+} // end count_if()
+
+
+} // end generic
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/distance.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/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last);
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/distance.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/distance.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/system/detail/generic/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+namespace detail
+{
+
+
+__thrust_exec_check_disable__
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last, thrust::incrementable_traversal_tag)
+{
+  typename thrust::iterator_traits<InputIterator>::difference_type result(0);
+
+  while(first != last)
+  {
+    ++first;
+    ++result;
+  } // end while
+
+  return result;
+} // end advance()
+
+
+__thrust_exec_check_disable__
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last, thrust::random_access_traversal_tag)
+{
+  return last - first;
+} // end distance()
+
+
+} // end detail
+
+__thrust_exec_check_disable__
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last)
+{
+  // dispatch on iterator traversal
+  return thrust::system::detail::generic::detail::distance(first, last,
+    typename thrust::iterator_traversal<InputIterator>::type());
+} // end advance()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/equal.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.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+bool equal(thrust::execution_policy<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
+
+
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+bool equal(thrust::execution_policy<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/equal.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/equal.inl

@@ -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/system/detail/generic/equal.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/internal_functional.h>
+#include <thrust/mismatch.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2>
+__host__ __device__
+bool equal(thrust::execution_policy<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
+  typedef typename thrust::iterator_traits<InputIterator1>::value_type InputType1;
+
+  return thrust::equal(exec, first1, last1, first2, thrust::detail::equal_to<InputType1>());
+}
+
+
+// the == below could be a __host__ function in the case of std::vector::iterator::operator==
+// we make this exception for equal and use __thrust_exec_check_disable__ because it is used in vector's implementation
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
+__host__ __device__
+bool equal(thrust::execution_policy<DerivedPolicy> &exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred)
+{
+  return thrust::mismatch(exec, first1, last1, first2, binary_pred).first == last1;
+}
+
+
+} // end generic
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/extrema.h

@@ -0,0 +1,88 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT 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 Generic device implementations of extrema functions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/pair.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator max_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator max_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator min_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator min_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp);
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(thrust::execution_policy<DerivedPolicy> &exec,
+                                                             ForwardIterator first, 
+                                                             ForwardIterator last);
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(thrust::execution_policy<DerivedPolicy> &exec,
+                                                             ForwardIterator first, 
+                                                             ForwardIterator last,
+                                                             BinaryPredicate comp);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/extrema.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/extrema.inl

@@ -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 distance.h
+ *  \brief Device implementations for distance.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/get_iterator_value.h>
+#include <thrust/extrema.h>
+#include <thrust/functional.h>
+#include <thrust/pair.h>
+#include <thrust/reduce.h>
+#include <thrust/transform_reduce.h>
+
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/zip_iterator.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+namespace detail
+{
+
+
+//////////////
+// Functors //
+//////////////
+//
+
+// return the smaller/larger element making sure to prefer the 
+// first occurance of the minimum/maximum element
+template <typename InputType, typename IndexType, typename BinaryPredicate>
+struct min_element_reduction
+{
+  BinaryPredicate comp;
+
+  __host__ __device__ 
+  min_element_reduction(BinaryPredicate comp) : comp(comp){}
+
+  __host__ __device__ 
+  thrust::tuple<InputType, IndexType>
+  operator()(const thrust::tuple<InputType, IndexType>& lhs, 
+             const thrust::tuple<InputType, IndexType>& rhs )
+  {
+    if(comp(thrust::get<0>(lhs), thrust::get<0>(rhs)))
+      return lhs;
+    if(comp(thrust::get<0>(rhs), thrust::get<0>(lhs)))
+      return rhs;
+
+    // values are equivalent, prefer value with smaller index
+    if(thrust::get<1>(lhs) < thrust::get<1>(rhs))
+      return lhs;
+    else
+      return rhs;
+  } // end operator()()
+}; // end min_element_reduction
+
+
+template <typename InputType, typename IndexType, typename BinaryPredicate>
+struct max_element_reduction
+{
+  BinaryPredicate comp;
+
+  __host__ __device__ 
+  max_element_reduction(BinaryPredicate comp) : comp(comp){}
+
+  __host__ __device__ 
+  thrust::tuple<InputType, IndexType>
+  operator()(const thrust::tuple<InputType, IndexType>& lhs, 
+             const thrust::tuple<InputType, IndexType>& rhs )
+  {
+    if(comp(thrust::get<0>(lhs), thrust::get<0>(rhs)))
+      return rhs;
+    if(comp(thrust::get<0>(rhs), thrust::get<0>(lhs)))
+      return lhs;
+
+    // values are equivalent, prefer value with smaller index
+    if(thrust::get<1>(lhs) < thrust::get<1>(rhs))
+      return lhs;
+    else
+      return rhs;
+  } // end operator()()
+}; // end max_element_reduction
+
+
+// return the smaller & larger element making sure to prefer the 
+// first occurance of the minimum/maximum element
+template <typename InputType, typename IndexType, typename BinaryPredicate>
+struct minmax_element_reduction
+{
+  BinaryPredicate comp;
+
+  __host__ __device__
+  minmax_element_reduction(BinaryPredicate comp) : comp(comp){}
+
+  __host__ __device__ 
+  thrust::tuple< thrust::tuple<InputType,IndexType>, thrust::tuple<InputType,IndexType> >
+  operator()(const thrust::tuple< thrust::tuple<InputType,IndexType>, thrust::tuple<InputType,IndexType> >& lhs, 
+             const thrust::tuple< thrust::tuple<InputType,IndexType>, thrust::tuple<InputType,IndexType> >& rhs )
+  {
+
+    return thrust::make_tuple(min_element_reduction<InputType, IndexType, BinaryPredicate>(comp)(thrust::get<0>(lhs), thrust::get<0>(rhs)),
+                              max_element_reduction<InputType, IndexType, BinaryPredicate>(comp)(thrust::get<1>(lhs), thrust::get<1>(rhs)));
+  } // end operator()()
+}; // end minmax_element_reduction
+
+
+template <typename InputType, typename IndexType>
+struct duplicate_tuple
+{
+  __host__ __device__ 
+  thrust::tuple< thrust::tuple<InputType,IndexType>, thrust::tuple<InputType,IndexType> >
+  operator()(const thrust::tuple<InputType,IndexType>& t)
+  {
+    return thrust::make_tuple(t, t);
+  }
+}; // end duplicate_tuple
+
+
+} // end namespace detail
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator min_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last)
+{
+  typedef typename thrust::iterator_value<ForwardIterator>::type value_type;
+
+  return thrust::min_element(exec, first, last, thrust::less<value_type>());
+} // end min_element()
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator min_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  if (first == last)
+    return last;
+
+  typedef typename thrust::iterator_traits<ForwardIterator>::value_type      InputType;
+  typedef typename thrust::iterator_traits<ForwardIterator>::difference_type IndexType;
+
+  thrust::tuple<InputType, IndexType> result =
+    thrust::reduce
+      (exec,
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))),
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))) + (last - first),
+       thrust::tuple<InputType, IndexType>(thrust::detail::get_iterator_value(derived_cast(exec), first), 0),
+       detail::min_element_reduction<InputType, IndexType, BinaryPredicate>(comp));
+
+  return first + thrust::get<1>(result);
+} // end min_element()
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator max_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last)
+{
+  typedef typename thrust::iterator_value<ForwardIterator>::type value_type;
+
+  return thrust::max_element(exec, first, last, thrust::less<value_type>());
+} // end max_element()
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator max_element(thrust::execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  if (first == last)
+    return last;
+
+  typedef typename thrust::iterator_traits<ForwardIterator>::value_type      InputType;
+  typedef typename thrust::iterator_traits<ForwardIterator>::difference_type IndexType;
+
+  thrust::tuple<InputType, IndexType> result =
+    thrust::reduce
+      (exec,
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))),
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))) + (last - first),
+       thrust::tuple<InputType, IndexType>(thrust::detail::get_iterator_value(derived_cast(exec),first), 0),
+       detail::max_element_reduction<InputType, IndexType, BinaryPredicate>(comp));
+
+  return first + thrust::get<1>(result);
+} // end max_element()
+
+
+template <typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(thrust::execution_policy<DerivedPolicy> &exec,
+                                                             ForwardIterator first, 
+                                                             ForwardIterator last)
+{
+  typedef typename thrust::iterator_value<ForwardIterator>::type value_type;
+
+  return thrust::minmax_element(exec, first, last, thrust::less<value_type>());
+} // end minmax_element()
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(thrust::execution_policy<DerivedPolicy> &exec,
+                                                             ForwardIterator first, 
+                                                             ForwardIterator last,
+                                                             BinaryPredicate comp)
+{
+  if (first == last)
+    return thrust::make_pair(last, last);
+
+  typedef typename thrust::iterator_traits<ForwardIterator>::value_type      InputType;
+  typedef typename thrust::iterator_traits<ForwardIterator>::difference_type IndexType;
+
+  thrust::tuple< thrust::tuple<InputType,IndexType>, thrust::tuple<InputType,IndexType> > result = 
+    thrust::transform_reduce
+      (exec,
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))),
+       thrust::make_zip_iterator(thrust::make_tuple(first, thrust::counting_iterator<IndexType>(0))) + (last - first),
+       detail::duplicate_tuple<InputType, IndexType>(),
+       detail::duplicate_tuple<InputType, IndexType>()(
+         thrust::tuple<InputType, IndexType>(thrust::detail::get_iterator_value(derived_cast(exec),first), 0)),
+       detail::minmax_element_reduction<InputType, IndexType, BinaryPredicate>(comp));
+
+  return thrust::make_pair(first + thrust::get<1>(thrust::get<0>(result)), first + thrust::get<1>(thrust::get<1>(result)));
+} // end minmax_element()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/fill.h

@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 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/internal_functional.h>
+#include <thrust/generate.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename OutputIterator, typename Size, typename T>
+__host__ __device__
+  OutputIterator fill_n(thrust::execution_policy<DerivedPolicy> &exec,
+                        OutputIterator first,
+                        Size n,
+                        const T &value)
+{
+  // XXX consider using the placeholder expression _1 = value
+  return thrust::generate_n(exec, first, n, thrust::detail::fill_functor<T>(value));
+}
+
+template<typename DerivedPolicy, typename ForwardIterator, typename T>
+__host__ __device__
+  void fill(thrust::execution_policy<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T &value)
+{
+  // XXX consider using the placeholder expression _1 = value
+  thrust::generate(exec, first, last, thrust::detail::fill_functor<T>(value));
+}
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/find.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/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+InputIterator find(thrust::execution_policy<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   const T& value);
+
+
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if(thrust::execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if_not(thrust::execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          Predicate pred);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/find.inl>
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/find.inl

@@ -0,0 +1,151 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 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/find.h>
+#include <thrust/reduce.h>
+
+#include <thrust/tuple.h>
+#include <thrust/detail/minmax.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/detail/internal_functional.h>
+
+
+// Contributed by Erich Elsen
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy, typename InputIterator, typename T>
+__host__ __device__
+InputIterator find(thrust::execution_policy<DerivedPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   const T& value)
+{
+  using thrust::placeholders::_1;
+
+  return thrust::find_if(exec, first, last, _1 == value);
+} // end find()
+
+
+template<typename TupleType>
+struct find_if_functor
+{
+  __host__ __device__
+  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;
+    }
+  }
+};
+
+
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if(thrust::execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  typedef typename thrust::iterator_traits<InputIterator>::difference_type difference_type;
+  typedef typename thrust::tuple<bool,difference_type> result_type;
+
+  // empty sequence
+  if(first == last) return last;
+
+  const difference_type n = thrust::distance(first, last);
+
+  // this implementation breaks up the sequence into separate intervals
+  // in an attempt to early-out as soon as a value is found
+
+  // TODO incorporate sizeof(InputType) into interval_threshold and round to multiple of 32
+  const difference_type interval_threshold = 1 << 20;
+  const difference_type interval_size = (thrust::min)(interval_threshold, n);
+
+  // force transform_iterator output to bool
+  typedef thrust::transform_iterator<Predicate, InputIterator, bool> XfrmIterator;
+  typedef thrust::tuple<XfrmIterator, thrust::counting_iterator<difference_type> > IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple> ZipIterator;
+
+  IteratorTuple iter_tuple = thrust::make_tuple(XfrmIterator(first, pred),
+                                                thrust::counting_iterator<difference_type>(0));
+
+  ZipIterator begin = thrust::make_zip_iterator(iter_tuple);
+  ZipIterator end   = begin + n;
+
+  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 = thrust::reduce(exec,
+                                        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 + n;
+}
+
+
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+InputIterator find_if_not(thrust::execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          Predicate pred)
+{
+  return thrust::find_if(exec, first, last, thrust::detail::not1(pred));
+} // end find()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/third_party/gpus/cuda/include/thrust/system/detail/generic/for_each.h

@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file for_each.h
+ *  \brief Generic implementation of for_each & for_each_n.
+ *         It is an error to call these functions; they have no implementation.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/system/detail/generic/tag.h>
+#include <thrust/detail/static_assert.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename UnaryFunction>
+__host__ __device__
+InputIterator for_each(thrust::execution_policy<DerivedPolicy> &,
+                       InputIterator first,
+                       InputIterator ,
+                       UnaryFunction )
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<InputIterator, false>::value)
+  , "unimplemented for this system"
+  );
+  return first;
+} // end for_each()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename UnaryFunction>
+__host__ __device__
+InputIterator for_each_n(thrust::execution_policy<DerivedPolicy> &,
+                         InputIterator first,
+                         Size ,
+                         UnaryFunction )
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<InputIterator, false>::value)
+  , "unimplemented for this system"
+  );
+  return first;
+} // end for_each_n()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+